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  * UFS2 write support Evgeniy Dushistov <dushistov@mail.ru>, 2007
   9  */
  10
  11 #include <linux/fs.h>
  12 #include <linux/stat.h>
  13 #include <linux/time.h>
  14 #include <linux/string.h>
  15 #include <linux/quotaops.h>
  16 #include <linux/buffer_head.h>
  17 #include <linux/capability.h>
  18 #include <linux/bitops.h>
  19 #include <asm/byteorder.h>
  20
  21 #include "ufs_fs.h"
  22 #include "ufs.h"
  23 #include "swab.h"
  24 #include "util.h"
  25
  26 #define INVBLOCK ((u64)-1L)
  27
  28 static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned, int *);
  29 static u64 ufs_alloc_fragments(struct inode *, unsigned, u64, unsigned, int *);
  30 static u64 ufs_alloccg_block(struct inode *, struct ufs_cg_private_info *, u64, int *);
  31 static u64 ufs_bitmap_search (struct super_block *, struct ufs_cg_private_info *, u64, unsigned);
  32 static unsigned char ufs_fragtable_8fpb[], ufs_fragtable_other[];
  33 static void ufs_clusteracct(struct super_block *, struct ufs_cg_private_info *, unsigned, int);
  34
  35 /*
  36  * Free 'count' fragments from fragment number 'fragment'
  37  */
  38 void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
  39 {
  40         struct super_block * sb;
  41         struct ufs_sb_private_info * uspi;
  42         struct ufs_super_block_first * usb1;
  43         struct ufs_cg_private_info * ucpi;
  44         struct ufs_cylinder_group * ucg;
  45         unsigned cgno, bit, end_bit, bbase, blkmap, i;
  46         u64 blkno;
  47
  48         sb = inode->i_sb;
  49         uspi = UFS_SB(sb)->s_uspi;
  50         usb1 = ubh_get_usb_first(uspi);
  51
  52         UFSD("ENTER, fragment %llu, count %u\n",
  53              (unsigned long long)fragment, count);
  54
  55         if (ufs_fragnum(fragment) + count > uspi->s_fpg)
  56                 ufs_error (sb, "ufs_free_fragments", "internal error");
  57
  58         lock_super(sb);
  59
  60         cgno = ufs_dtog(uspi, fragment);
  61         bit = ufs_dtogd(uspi, fragment);
  62         if (cgno >= uspi->s_ncg) {
  63                 ufs_panic (sb, "ufs_free_fragments", "freeing blocks are outside device");
  64                 goto failed;
  65         }
  66
  67         ucpi = ufs_load_cylinder (sb, cgno);
  68         if (!ucpi)
  69                 goto failed;
  70         ucg = ubh_get_ucg (UCPI_UBH(ucpi));
  71         if (!ufs_cg_chkmagic(sb, ucg)) {
  72                 ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);
  73                 goto failed;
  74         }
  75
  76         end_bit = bit + count;
  77         bbase = ufs_blknum (bit);
  78         blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
  79         ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1);
  80         for (i = bit; i < end_bit; i++) {
  81                 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, i))
  82                         ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, i);
  83                 else
  84                         ufs_error (sb, "ufs_free_fragments",
  85                                    "bit already cleared for fragment %u", i);
  86         }
  87
  88         dquot_free_block(inode, count);
  89
  90
  91         fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
  92         uspi->cs_total.cs_nffree += count;
  93         fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
  94         blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
  95         ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);
  96
  97         /*
  98          * Trying to reassemble free fragments into block
  99          */
 100         blkno = ufs_fragstoblks (bbase);
 101         if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
 102                 fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb);
 103                 uspi->cs_total.cs_nffree -= uspi->s_fpb;
 104                 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, uspi->s_fpb);
 105                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
 106                         ufs_clusteracct (sb, ucpi, blkno, 1);
 107                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
 108                 uspi->cs_total.cs_nbfree++;
 109                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
 110                 if (uspi->fs_magic != UFS2_MAGIC) {
 111                         unsigned cylno = ufs_cbtocylno (bbase);
 112
 113                         fs16_add(sb, &ubh_cg_blks(ucpi, cylno,
 114                                                   ufs_cbtorpos(bbase)), 1);
 115                         fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
 116                 }
 117         }
 118
 119         ubh_mark_buffer_dirty (USPI_UBH(uspi));
 120         ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
 121         if (sb->s_flags & MS_SYNCHRONOUS) {
 122                 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
 123                 ubh_wait_on_buffer (UCPI_UBH(ucpi));
 124         }
 125         sb->s_dirt = 1;
 126
 127         unlock_super (sb);
 128         UFSD("EXIT\n");
 129         return;
 130
 131 failed:
 132         unlock_super (sb);
 133         UFSD("EXIT (FAILED)\n");
 134         return;
 135 }
 136
 137 /*
 138  * Free 'count' fragments from fragment number 'fragment' (free whole blocks)
 139  */
 140 void ufs_free_blocks(struct inode *inode, u64 fragment, unsigned count)
 141 {
 142         struct super_block * sb;
 143         struct ufs_sb_private_info * uspi;
 144         struct ufs_super_block_first * usb1;
 145         struct ufs_cg_private_info * ucpi;
 146         struct ufs_cylinder_group * ucg;
 147         unsigned overflow, cgno, bit, end_bit, i;
 148         u64 blkno;
 149
 150         sb = inode->i_sb;
 151         uspi = UFS_SB(sb)->s_uspi;
 152         usb1 = ubh_get_usb_first(uspi);
 153
 154         UFSD("ENTER, fragment %llu, count %u\n",
 155              (unsigned long long)fragment, count);
 156
 157         if ((fragment & uspi->s_fpbmask) || (count & uspi->s_fpbmask)) {
 158                 ufs_error (sb, "ufs_free_blocks", "internal error, "
 159                            "fragment %llu, count %u\n",
 160                            (unsigned long long)fragment, count);
 161                 goto failed;
 162         }
 163
 164         lock_super(sb);
 165
 166 do_more:
 167         overflow = 0;
 168         cgno = ufs_dtog(uspi, fragment);
 169         bit = ufs_dtogd(uspi, fragment);
 170         if (cgno >= uspi->s_ncg) {
 171                 ufs_panic (sb, "ufs_free_blocks", "freeing blocks are outside device");
 172                 goto failed_unlock;
 173         }
 174         end_bit = bit + count;
 175         if (end_bit > uspi->s_fpg) {
 176                 overflow = bit + count - uspi->s_fpg;
 177                 count -= overflow;
 178                 end_bit -= overflow;
 179         }
 180
 181         ucpi = ufs_load_cylinder (sb, cgno);
 182         if (!ucpi)
 183                 goto failed_unlock;
 184         ucg = ubh_get_ucg (UCPI_UBH(ucpi));
 185         if (!ufs_cg_chkmagic(sb, ucg)) {
 186                 ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);
 187                 goto failed_unlock;
 188         }
 189
 190         for (i = bit; i < end_bit; i += uspi->s_fpb) {
 191                 blkno = ufs_fragstoblks(i);
 192                 if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
 193                         ufs_error(sb, "ufs_free_blocks", "freeing free fragment");
 194                 }
 195                 ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
 196                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
 197                         ufs_clusteracct (sb, ucpi, blkno, 1);
 198                 dquot_free_block(inode, uspi->s_fpb);
 199
 200                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
 201                 uspi->cs_total.cs_nbfree++;
 202                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
 203
 204                 if (uspi->fs_magic != UFS2_MAGIC) {
 205                         unsigned cylno = ufs_cbtocylno(i);
 206
 207                         fs16_add(sb, &ubh_cg_blks(ucpi, cylno,
 208                                                   ufs_cbtorpos(i)), 1);
 209                         fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
 210                 }
 211         }
 212
 213         ubh_mark_buffer_dirty (USPI_UBH(uspi));
 214         ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
 215         if (sb->s_flags & MS_SYNCHRONOUS) {
 216                 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
 217                 ubh_wait_on_buffer (UCPI_UBH(ucpi));
 218         }
 219
 220         if (overflow) {
 221                 fragment += count;
 222                 count = overflow;
 223                 goto do_more;
 224         }
 225
 226         sb->s_dirt = 1;
 227         unlock_super (sb);
 228         UFSD("EXIT\n");
 229         return;
 230
 231 failed_unlock:
 232         unlock_super (sb);
 233 failed:
 234         UFSD("EXIT (FAILED)\n");
 235         return;
 236 }
 237
 238 /*
 239  * Modify inode page cache in such way:
 240  * have - blocks with b_blocknr equal to oldb...oldb+count-1
 241  * get - blocks with b_blocknr equal to newb...newb+count-1
 242  * also we suppose that oldb...oldb+count-1 blocks
 243  * situated at the end of file.
 244  *
 245  * We can come here from ufs_writepage or ufs_prepare_write,
 246  * locked_page is argument of these functions, so we already lock it.
 247  */
 248 static void ufs_change_blocknr(struct inode *inode, sector_t beg,
 249                                unsigned int count, sector_t oldb,
 250                                sector_t newb, struct page *locked_page)
 251 {
 252         const unsigned blks_per_page =
 253                 1 << (PAGE_CACHE_SHIFT - inode->i_blkbits);
 254         const unsigned mask = blks_per_page - 1;
 255         struct address_space * const mapping = inode->i_mapping;
 256         pgoff_t index, cur_index, last_index;
 257         unsigned pos, j, lblock;
 258         sector_t end, i;
 259         struct page *page;
 260         struct buffer_head *head, *bh;
 261
 262         UFSD("ENTER, ino %lu, count %u, oldb %llu, newb %llu\n",
 263               inode->i_ino, count,
 264              (unsigned long long)oldb, (unsigned long long)newb);
 265
 266         BUG_ON(!locked_page);
 267         BUG_ON(!PageLocked(locked_page));
 268
 269         cur_index = locked_page->index;
 270         end = count + beg;
 271         last_index = end >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
 272         for (i = beg; i < end; i = (i | mask) + 1) {
 273                 index = i >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
 274
 275                 if (likely(cur_index != index)) {
 276                         page = ufs_get_locked_page(mapping, index);
 277                         if (!page)/* it was truncated */
 278                                 continue;
 279                         if (IS_ERR(page)) {/* or EIO */
 280                                 ufs_error(inode->i_sb, __func__,
 281                                           "read of page %llu failed\n",
 282                                           (unsigned long long)index);
 283                                 continue;
 284                         }
 285                 } else
 286                         page = locked_page;
 287
 288                 head = page_buffers(page);
 289                 bh = head;
 290                 pos = i & mask;
 291                 for (j = 0; j < pos; ++j)
 292                         bh = bh->b_this_page;
 293
 294
 295                 if (unlikely(index == last_index))
 296                         lblock = end & mask;
 297                 else
 298                         lblock = blks_per_page;
 299
 300                 do {
 301                         if (j >= lblock)
 302                                 break;
 303                         pos = (i - beg) + j;
 304
 305                         if (!buffer_mapped(bh))
 306                                         map_bh(bh, inode->i_sb, oldb + pos);
 307                         if (!buffer_uptodate(bh)) {
 308                                 ll_rw_block(READ, 1, &bh);
 309                                 wait_on_buffer(bh);
 310                                 if (!buffer_uptodate(bh)) {
 311                                         ufs_error(inode->i_sb, __func__,
 312                                                   "read of block failed\n");
 313                                         break;
 314                                 }
 315                         }
 316
 317                         UFSD(" change from %llu to %llu, pos %u\n",
 318                              (unsigned long long)(pos + oldb),
 319                              (unsigned long long)(pos + newb), pos);
 320
 321                         bh->b_blocknr = newb + pos;
 322                         unmap_underlying_metadata(bh->b_bdev,
 323                                                   bh->b_blocknr);
 324                         mark_buffer_dirty(bh);
 325                         ++j;
 326                         bh = bh->b_this_page;
 327                 } while (bh != head);
 328
 329                 if (likely(cur_index != index))
 330                         ufs_put_locked_page(page);
 331         }
 332         UFSD("EXIT\n");
 333 }
 334
 335 static void ufs_clear_frags(struct inode *inode, sector_t beg, unsigned int n,
 336                             int sync)
 337 {
 338         struct buffer_head *bh;
 339         sector_t end = beg + n;
 340
 341         for (; beg < end; ++beg) {
 342                 bh = sb_getblk(inode->i_sb, beg);
 343                 lock_buffer(bh);
 344                 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
 345                 set_buffer_uptodate(bh);
 346                 mark_buffer_dirty(bh);
 347                 unlock_buffer(bh);
 348                 if (IS_SYNC(inode) || sync)
 349                         sync_dirty_buffer(bh);
 350                 brelse(bh);
 351         }
 352 }
 353
 354 u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
 355                            u64 goal, unsigned count, int *err,
 356                            struct page *locked_page)
 357 {
 358         struct super_block * sb;
 359         struct ufs_sb_private_info * uspi;
 360         struct ufs_super_block_first * usb1;
 361         unsigned cgno, oldcount, newcount;
 362         u64 tmp, request, result;
 363
 364         UFSD("ENTER, ino %lu, fragment %llu, goal %llu, count %u\n",
 365              inode->i_ino, (unsigned long long)fragment,
 366              (unsigned long long)goal, count);
 367
 368         sb = inode->i_sb;
 369         uspi = UFS_SB(sb)->s_uspi;
 370         usb1 = ubh_get_usb_first(uspi);
 371         *err = -ENOSPC;
 372
 373         lock_super (sb);
 374         tmp = ufs_data_ptr_to_cpu(sb, p);
 375
 376         if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
 377                 ufs_warning(sb, "ufs_new_fragments", "internal warning"
 378                             " fragment %llu, count %u",
 379                             (unsigned long long)fragment, count);
 380                 count = uspi->s_fpb - ufs_fragnum(fragment);
 381         }
 382         oldcount = ufs_fragnum (fragment);
 383         newcount = oldcount + count;
 384
 385         /*
 386          * Somebody else has just allocated our fragments
 387          */
 388         if (oldcount) {
 389                 if (!tmp) {
 390                         ufs_error(sb, "ufs_new_fragments", "internal error, "
 391                                   "fragment %llu, tmp %llu\n",
 392                                   (unsigned long long)fragment,
 393                                   (unsigned long long)tmp);
 394                         unlock_super(sb);
 395                         return INVBLOCK;
 396                 }
 397                 if (fragment < UFS_I(inode)->i_lastfrag) {
 398                         UFSD("EXIT (ALREADY ALLOCATED)\n");
 399                         unlock_super (sb);
 400                         return 0;
 401                 }
 402         }
 403         else {
 404                 if (tmp) {
 405                         UFSD("EXIT (ALREADY ALLOCATED)\n");
 406                         unlock_super(sb);
 407                         return 0;
 408                 }
 409         }
 410
 411         /*
 412          * There is not enough space for user on the device
 413          */
 414         if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
 415                 unlock_super (sb);
 416                 UFSD("EXIT (FAILED)\n");
 417                 return 0;
 418         }
 419
 420         if (goal >= uspi->s_size)
 421                 goal = 0;
 422         if (goal == 0)
 423                 cgno = ufs_inotocg (inode->i_ino);
 424         else
 425                 cgno = ufs_dtog(uspi, goal);
 426
 427         /*
 428          * allocate new fragment
 429          */
 430         if (oldcount == 0) {
 431                 result = ufs_alloc_fragments (inode, cgno, goal, count, err);
 432                 if (result) {
 433                         ufs_cpu_to_data_ptr(sb, p, result);
 434                         *err = 0;
 435                         UFS_I(inode)->i_lastfrag =
 436                                 max_t(u32, UFS_I(inode)->i_lastfrag,
 437                                       fragment + count);
 438                         ufs_clear_frags(inode, result + oldcount,
 439                                         newcount - oldcount, locked_page != NULL);
 440                 }
 441                 unlock_super(sb);
 442                 UFSD("EXIT, result %llu\n", (unsigned long long)result);
 443                 return result;
 444         }
 445
 446         /*
 447          * resize block
 448          */
 449         result = ufs_add_fragments (inode, tmp, oldcount, newcount, err);
 450         if (result) {
 451                 *err = 0;
 452                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
 453                 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
 454                                 locked_page != NULL);
 455                 unlock_super(sb);
 456                 UFSD("EXIT, result %llu\n", (unsigned long long)result);
 457                 return result;
 458         }
 459
 460         /*
 461          * allocate new block and move data
 462          */
 463         switch (fs32_to_cpu(sb, usb1->fs_optim)) {
 464             case UFS_OPTSPACE:
 465                 request = newcount;
 466                 if (uspi->s_minfree < 5 || uspi->cs_total.cs_nffree
 467                     > uspi->s_dsize * uspi->s_minfree / (2 * 100))
 468                         break;
 469                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
 470                 break;
 471             default:
 472                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
 473
 474             case UFS_OPTTIME:
 475                 request = uspi->s_fpb;
 476                 if (uspi->cs_total.cs_nffree < uspi->s_dsize *
 477                     (uspi->s_minfree - 2) / 100)
 478                         break;
 479                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
 480                 break;
 481         }
 482         result = ufs_alloc_fragments (inode, cgno, goal, request, err);
 483         if (result) {
 484                 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
 485                                 locked_page != NULL);
 486                 ufs_change_blocknr(inode, fragment - oldcount, oldcount,
 487                                    uspi->s_sbbase + tmp,
 488                                    uspi->s_sbbase + result, locked_page);
 489                 ufs_cpu_to_data_ptr(sb, p, result);
 490                 *err = 0;
 491                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
 492                 unlock_super(sb);
 493                 if (newcount < request)
 494                         ufs_free_fragments (inode, result + newcount, request - newcount);
 495                 ufs_free_fragments (inode, tmp, oldcount);
 496                 UFSD("EXIT, result %llu\n", (unsigned long long)result);
 497                 return result;
 498         }
 499
 500         unlock_super(sb);
 501         UFSD("EXIT (FAILED)\n");
 502         return 0;
 503 }
 504
 505 static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
 506                              unsigned oldcount, unsigned newcount, int *err)
 507 {
 508         struct super_block * sb;
 509         struct ufs_sb_private_info * uspi;
 510         struct ufs_super_block_first * usb1;
 511         struct ufs_cg_private_info * ucpi;
 512         struct ufs_cylinder_group * ucg;
 513         unsigned cgno, fragno, fragoff, count, fragsize, i;
 514         int ret;
 515
 516         UFSD("ENTER, fragment %llu, oldcount %u, newcount %u\n",
 517              (unsigned long long)fragment, oldcount, newcount);
 518
 519         sb = inode->i_sb;
 520         uspi = UFS_SB(sb)->s_uspi;
 521         usb1 = ubh_get_usb_first (uspi);
 522         count = newcount - oldcount;
 523
 524         cgno = ufs_dtog(uspi, fragment);
 525         if (fs32_to_cpu(sb, UFS_SB(sb)->fs_cs(cgno).cs_nffree) < count)
 526                 return 0;
 527         if ((ufs_fragnum (fragment) + newcount) > uspi->s_fpb)
 528                 return 0;
 529         ucpi = ufs_load_cylinder (sb, cgno);
 530         if (!ucpi)
 531                 return 0;
 532         ucg = ubh_get_ucg (UCPI_UBH(ucpi));
 533         if (!ufs_cg_chkmagic(sb, ucg)) {
 534                 ufs_panic (sb, "ufs_add_fragments",
 535                         "internal error, bad magic number on cg %u", cgno);
 536                 return 0;
 537         }
 538
 539         fragno = ufs_dtogd(uspi, fragment);
 540         fragoff = ufs_fragnum (fragno);
 541         for (i = oldcount; i < newcount; i++)
 542                 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
 543                         return 0;
 544         /*
 545          * Block can be extended
 546          */
 547         ucg->cg_time = cpu_to_fs32(sb, get_seconds());
 548         for (i = newcount; i < (uspi->s_fpb - fragoff); i++)
 549                 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
 550                         break;
 551         fragsize = i - oldcount;
 552         if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
 553                 ufs_panic (sb, "ufs_add_fragments",
 554                         "internal error or corrupted bitmap on cg %u", cgno);
 555         fs32_sub(sb, &ucg->cg_frsum[fragsize], 1);
 556         if (fragsize != count)
 557                 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
 558         for (i = oldcount; i < newcount; i++)
 559                 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i);
 560         ret = dquot_alloc_block(inode, count);
 561         if (ret) {
 562                 *err = ret;
 563                 return 0;
 564         }
 565
 566         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
 567         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
 568         uspi->cs_total.cs_nffree -= count;
 569
 570         ubh_mark_buffer_dirty (USPI_UBH(uspi));
 571         ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
 572         if (sb->s_flags & MS_SYNCHRONOUS) {
 573                 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
 574                 ubh_wait_on_buffer (UCPI_UBH(ucpi));
 575         }
 576         sb->s_dirt = 1;
 577
 578         UFSD("EXIT, fragment %llu\n", (unsigned long long)fragment);
 579
 580         return fragment;
 581 }
 582
 583 #define UFS_TEST_FREE_SPACE_CG \
 584         ucg = (struct ufs_cylinder_group *) UFS_SB(sb)->s_ucg[cgno]->b_data; \
 585         if (fs32_to_cpu(sb, ucg->cg_cs.cs_nbfree)) \
 586                 goto cg_found; \
 587         for (k = count; k < uspi->s_fpb; k++) \
 588                 if (fs32_to_cpu(sb, ucg->cg_frsum[k])) \
 589                         goto cg_found;
 590
 591 static u64 ufs_alloc_fragments(struct inode *inode, unsigned cgno,
 592                                u64 goal, unsigned count, int *err)
 593 {
 594         struct super_block * sb;
 595         struct ufs_sb_private_info * uspi;
 596         struct ufs_super_block_first * usb1;
 597         struct ufs_cg_private_info * ucpi;
 598         struct ufs_cylinder_group * ucg;
 599         unsigned oldcg, i, j, k, allocsize;
 600         u64 result;
 601         int ret;
 602
 603         UFSD("ENTER, ino %lu, cgno %u, goal %llu, count %u\n",
 604              inode->i_ino, cgno, (unsigned long long)goal, count);
 605
 606         sb = inode->i_sb;
 607         uspi = UFS_SB(sb)->s_uspi;
 608         usb1 = ubh_get_usb_first(uspi);
 609         oldcg = cgno;
 610
 611         /*
 612          * 1. searching on preferred cylinder group
 613          */
 614         UFS_TEST_FREE_SPACE_CG
 615
 616         /*
 617          * 2. quadratic rehash
 618          */
 619         for (j = 1; j < uspi->s_ncg; j *= 2) {
 620                 cgno += j;
 621                 if (cgno >= uspi->s_ncg)
 622                         cgno -= uspi->s_ncg;
 623                 UFS_TEST_FREE_SPACE_CG
 624         }
 625
 626         /*
 627          * 3. brute force search
 628          * We start at i = 2 ( 0 is checked at 1.step, 1 at 2.step )
 629          */
 630         cgno = (oldcg + 1) % uspi->s_ncg;
 631         for (j = 2; j < uspi->s_ncg; j++) {
 632                 cgno++;
 633                 if (cgno >= uspi->s_ncg)
 634                         cgno = 0;
 635                 UFS_TEST_FREE_SPACE_CG
 636         }
 637
 638         UFSD("EXIT (FAILED)\n");
 639         return 0;
 640
 641 cg_found:
 642         ucpi = ufs_load_cylinder (sb, cgno);
 643         if (!ucpi)
 644                 return 0;
 645         ucg = ubh_get_ucg (UCPI_UBH(ucpi));
 646         if (!ufs_cg_chkmagic(sb, ucg))
 647                 ufs_panic (sb, "ufs_alloc_fragments",
 648                         "internal error, bad magic number on cg %u", cgno);
 649         ucg->cg_time = cpu_to_fs32(sb, get_seconds());
 650
 651         if (count == uspi->s_fpb) {
 652                 result = ufs_alloccg_block (inode, ucpi, goal, err);
 653                 if (result == INVBLOCK)
 654                         return 0;
 655                 goto succed;
 656         }
 657
 658         for (allocsize = count; allocsize < uspi->s_fpb; allocsize++)
 659                 if (fs32_to_cpu(sb, ucg->cg_frsum[allocsize]) != 0)
 660                         break;
 661
 662         if (allocsize == uspi->s_fpb) {
 663                 result = ufs_alloccg_block (inode, ucpi, goal, err);
 664                 if (result == INVBLOCK)
 665                         return 0;
 666                 goal = ufs_dtogd(uspi, result);
 667                 for (i = count; i < uspi->s_fpb; i++)
 668                         ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
 669                 i = uspi->s_fpb - count;
 670                 dquot_free_block(inode, i);
 671
 672                 fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
 673                 uspi->cs_total.cs_nffree += i;
 674                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, i);
 675                 fs32_add(sb, &ucg->cg_frsum[i], 1);
 676                 goto succed;
 677         }
 678
 679         result = ufs_bitmap_search (sb, ucpi, goal, allocsize);
 680         if (result == INVBLOCK)
 681                 return 0;
 682         ret = dquot_alloc_block(inode, count);
 683         if (ret) {
 684                 *err = ret;
 685                 return 0;
 686         }
 687         for (i = 0; i < count; i++)
 688                 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, result + i);
 689
 690         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
 691         uspi->cs_total.cs_nffree -= count;
 692         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
 693         fs32_sub(sb, &ucg->cg_frsum[allocsize], 1);
 694
 695         if (count != allocsize)
 696                 fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1);
 697
 698 succed:
 699         ubh_mark_buffer_dirty (USPI_UBH(uspi));
 700         ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
 701         if (sb->s_flags & MS_SYNCHRONOUS) {
 702                 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
 703                 ubh_wait_on_buffer (UCPI_UBH(ucpi));
 704         }
 705         sb->s_dirt = 1;
 706
 707         result += cgno * uspi->s_fpg;
 708         UFSD("EXIT3, result %llu\n", (unsigned long long)result);
 709         return result;
 710 }
 711
 712 static u64 ufs_alloccg_block(struct inode *inode,
 713                              struct ufs_cg_private_info *ucpi,
 714                              u64 goal, int *err)
 715 {
 716         struct super_block * sb;
 717         struct ufs_sb_private_info * uspi;
 718         struct ufs_super_block_first * usb1;
 719         struct ufs_cylinder_group * ucg;
 720         u64 result, blkno;
 721         int ret;
 722
 723         UFSD("ENTER, goal %llu\n", (unsigned long long)goal);
 724
 725         sb = inode->i_sb;
 726         uspi = UFS_SB(sb)->s_uspi;
 727         usb1 = ubh_get_usb_first(uspi);
 728         ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 729
 730         if (goal == 0) {
 731                 goal = ucpi->c_rotor;
 732                 goto norot;
 733         }
 734         goal = ufs_blknum (goal);
 735         goal = ufs_dtogd(uspi, goal);
 736
 737         /*
 738          * If the requested block is available, use it.
 739          */
 740         if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, ufs_fragstoblks(goal))) {
 741                 result = goal;
 742                 goto gotit;
 743         }
 744
 745 norot:
 746         result = ufs_bitmap_search (sb, ucpi, goal, uspi->s_fpb);
 747         if (result == INVBLOCK)
 748                 return INVBLOCK;
 749         ucpi->c_rotor = result;
 750 gotit:
 751         blkno = ufs_fragstoblks(result);
 752         ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
 753         if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
 754                 ufs_clusteracct (sb, ucpi, blkno, -1);
 755         ret = dquot_alloc_block(inode, uspi->s_fpb);
 756         if (ret) {
 757                 *err = ret;
 758                 return INVBLOCK;
 759         }
 760
 761         fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1);
 762         uspi->cs_total.cs_nbfree--;
 763         fs32_sub(sb, &UFS_SB(sb)->fs_cs(ucpi->c_cgx).cs_nbfree, 1);
 764
 765         if (uspi->fs_magic != UFS2_MAGIC) {
 766                 unsigned cylno = ufs_cbtocylno((unsigned)result);
 767
 768                 fs16_sub(sb, &ubh_cg_blks(ucpi, cylno,
 769                                           ufs_cbtorpos((unsigned)result)), 1);
 770                 fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1);
 771         }
 772
 773         UFSD("EXIT, result %llu\n", (unsigned long long)result);
 774
 775         return result;
 776 }
 777
 778 static unsigned ubh_scanc(struct ufs_sb_private_info *uspi,
 779                           struct ufs_buffer_head *ubh,
 780                           unsigned begin, unsigned size,
 781                           unsigned char *table, unsigned char mask)
 782 {
 783         unsigned rest, offset;
 784         unsigned char *cp;
 785
 786
 787         offset = begin & ~uspi->s_fmask;
 788         begin >>= uspi->s_fshift;
 789         for (;;) {
 790                 if ((offset + size) < uspi->s_fsize)
 791                         rest = size;
 792                 else
 793                         rest = uspi->s_fsize - offset;
 794                 size -= rest;
 795                 cp = ubh->bh[begin]->b_data + offset;
 796                 while ((table[*cp++] & mask) == 0 && --rest)
 797                         ;
 798                 if (rest || !size)
 799                         break;
 800                 begin++;
 801                 offset = 0;
 802         }
 803         return (size + rest);
 804 }
 805
 806 /*
 807  * Find a block of the specified size in the specified cylinder group.
 808  * @sp: pointer to super block
 809  * @ucpi: pointer to cylinder group info
 810  * @goal: near which block we want find new one
 811  * @count: specified size
 812  */
 813 static u64 ufs_bitmap_search(struct super_block *sb,
 814                              struct ufs_cg_private_info *ucpi,
 815                              u64 goal, unsigned count)
 816 {
 817         /*
 818          * Bit patterns for identifying fragments in the block map
 819          * used as ((map & mask_arr) == want_arr)
 820          */
 821         static const int mask_arr[9] = {
 822                 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff
 823         };
 824         static const int want_arr[9] = {
 825                 0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe
 826         };
 827         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
 828         struct ufs_super_block_first *usb1;
 829         struct ufs_cylinder_group *ucg;
 830         unsigned start, length, loc;
 831         unsigned pos, want, blockmap, mask, end;
 832         u64 result;
 833
 834         UFSD("ENTER, cg %u, goal %llu, count %u\n", ucpi->c_cgx,
 835              (unsigned long long)goal, count);
 836
 837         usb1 = ubh_get_usb_first (uspi);
 838         ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 839
 840         if (goal)
 841                 start = ufs_dtogd(uspi, goal) >> 3;
 842         else
 843                 start = ucpi->c_frotor >> 3;
 844
 845         length = ((uspi->s_fpg + 7) >> 3) - start;
 846         loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff + start, length,
 847                 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
 848                 1 << (count - 1 + (uspi->s_fpb & 7)));
 849         if (loc == 0) {
 850                 length = start + 1;
 851                 loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff, length,
 852                                 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb :
 853                                 ufs_fragtable_other,
 854                                 1 << (count - 1 + (uspi->s_fpb & 7)));
 855                 if (loc == 0) {
 856                         ufs_error(sb, "ufs_bitmap_search",
 857                                   "bitmap corrupted on cg %u, start %u,"
 858                                   " length %u, count %u, freeoff %u\n",
 859                                   ucpi->c_cgx, start, length, count,
 860                                   ucpi->c_freeoff);
 861                         return INVBLOCK;
 862                 }
 863                 start = 0;
 864         }
 865         result = (start + length - loc) << 3;
 866         ucpi->c_frotor = result;
 867
 868         /*
 869          * found the byte in the map
 870          */
 871
 872         for (end = result + 8; result < end; result += uspi->s_fpb) {
 873                 blockmap = ubh_blkmap(UCPI_UBH(ucpi), ucpi->c_freeoff, result);
 874                 blockmap <<= 1;
 875                 mask = mask_arr[count];
 876                 want = want_arr[count];
 877                 for (pos = 0; pos <= uspi->s_fpb - count; pos++) {
 878                         if ((blockmap & mask) == want) {
 879                                 UFSD("EXIT, result %llu\n",
 880                                      (unsigned long long)result);
 881                                 return result + pos;
 882                         }
 883                         mask <<= 1;
 884                         want <<= 1;
 885                 }
 886         }
 887
 888         ufs_error(sb, "ufs_bitmap_search", "block not in map on cg %u\n",
 889                   ucpi->c_cgx);
 890         UFSD("EXIT (FAILED)\n");
 891         return INVBLOCK;
 892 }
 893
 894 static void ufs_clusteracct(struct super_block * sb,
 895         struct ufs_cg_private_info * ucpi, unsigned blkno, int cnt)
 896 {
 897         struct ufs_sb_private_info * uspi;
 898         int i, start, end, forw, back;
 899
 900         uspi = UFS_SB(sb)->s_uspi;
 901         if (uspi->s_contigsumsize <= 0)
 902                 return;
 903
 904         if (cnt > 0)
 905                 ubh_setbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
 906         else
 907                 ubh_clrbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
 908
 909         /*
 910          * Find the size of the cluster going forward.
 911          */
 912         start = blkno + 1;
 913         end = start + uspi->s_contigsumsize;
 914         if ( end >= ucpi->c_nclusterblks)
 915                 end = ucpi->c_nclusterblks;
 916         i = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, end, start);
 917         if (i > end)
 918                 i = end;
 919         forw = i - start;
 920
 921         /*
 922          * Find the size of the cluster going backward.
 923          */
 924         start = blkno - 1;
 925         end = start - uspi->s_contigsumsize;
 926         if (end < 0 )
 927                 end = -1;
 928         i = ubh_find_last_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, start, end);
 929         if ( i < end)
 930                 i = end;
 931         back = start - i;
 932
 933         /*
 934          * Account for old cluster and the possibly new forward and
 935          * back clusters.
 936          */
 937         i = back + forw + 1;
 938         if (i > uspi->s_contigsumsize)
 939                 i = uspi->s_contigsumsize;
 940         fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (i << 2)), cnt);
 941         if (back > 0)
 942                 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (back << 2)), cnt);
 943         if (forw > 0)
 944                 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (forw << 2)), cnt);
 945 }
 946
 947
 948 static unsigned char ufs_fragtable_8fpb[] = {
 949         0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08,
 950         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x08, 0x10,
 951         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
 952         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x04, 0x05, 0x05, 0x06, 0x08, 0x09, 0x10, 0x20,
 953         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
 954         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
 955         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A,
 956         0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x08, 0x09, 0x09, 0x0A, 0x10, 0x11, 0x20, 0x40,
 957         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
 958         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
 959         0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
 960         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x05, 0x05, 0x05, 0x07, 0x09, 0x09, 0x11, 0x21,
 961         0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A,
 962         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x02, 0x03, 0x03, 0x02, 0x06, 0x07, 0x0A, 0x12,
 963         0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x05, 0x07, 0x06, 0x07, 0x04, 0x0C,
 964         0x08, 0x09, 0x09, 0x0A, 0x09, 0x09, 0x0A, 0x0C, 0x10, 0x11, 0x11, 0x12, 0x20, 0x21, 0x40, 0x80,
 965 };
 966
 967 static unsigned char ufs_fragtable_other[] = {
 968         0x00, 0x16, 0x16, 0x2A, 0x16, 0x16, 0x26, 0x4E, 0x16, 0x16, 0x16, 0x3E, 0x2A, 0x3E, 0x4E, 0x8A,
 969         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 970         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 971         0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA,
 972         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 973         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 974         0x26, 0x36, 0x36, 0x2E, 0x36, 0x36, 0x26, 0x6E, 0x36, 0x36, 0x36, 0x3E, 0x2E, 0x3E, 0x6E, 0xAE,
 975         0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE,
 976         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 977         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 978         0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E,
 979         0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE,
 980         0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA,
 981         0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE,
 982         0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE,
 983         0x8A, 0x9E, 0x9E, 0xAA, 0x9E, 0x9E, 0xAE, 0xCE, 0x9E, 0x9E, 0x9E, 0xBE, 0xAA, 0xBE, 0xCE, 0x8A,
 984 };