release/src-rt/linux/linux-2.6/fs/exfat/exfat_cache.c

   1 /*
   2  *  Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  *  This program is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU General Public License
   6  *  as published by the Free Software Foundation; either version 2
   7  *  of the License, or (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 /************************************************************************/
  20 /*                                                                      */
  21 /*  PROJECT : exFAT & FAT12/16/32 File System                           */
  22 /*  FILE    : exfat_cache.c                                             */
  23 /*  PURPOSE : exFAT Cache Manager                                       */
  24 /*            (FAT Cache & Buffer Cache)                                */
  25 /*                                                                      */
  26 /*----------------------------------------------------------------------*/
  27 /*  NOTES                                                               */
  28 /*                                                                      */
  29 /*----------------------------------------------------------------------*/
  30 /*  REVISION HISTORY (Ver 0.9)                                          */
  31 /*                                                                      */
  32 /*  - 2010.11.15 [Sung-Kwan Kim] : first writing                        */
  33 /*                                                                      */
  34 /************************************************************************/
  35
  36 #include "exfat_config.h"
  37 #include "exfat_global.h"
  38 #include "exfat_data.h"
  39
  40 #include "exfat_cache.h"
  41 #include "exfat_super.h"
  42 #include "exfat.h"
  43
  44 /*----------------------------------------------------------------------*/
  45 /*  Global Variable Definitions                                         */
  46 /*----------------------------------------------------------------------*/
  47
  48 extern FS_STRUCT_T      fs_struct[];
  49
  50 #define sm_P(s)
  51 #define sm_V(s)
  52
  53 static INT32 __FAT_read(struct super_block *sb, UINT32 loc, UINT32 *content);
  54 static INT32 __FAT_write(struct super_block *sb, UINT32 loc, UINT32 content);
  55
  56 static BUF_CACHE_T *FAT_cache_find(struct super_block *sb, UINT32 sec);
  57 static BUF_CACHE_T *FAT_cache_get(struct super_block *sb, UINT32 sec);
  58 static void FAT_cache_insert_hash(struct super_block *sb, BUF_CACHE_T *bp);
  59 static void FAT_cache_remove_hash(BUF_CACHE_T *bp);
  60
  61 static UINT8 *__buf_getblk(struct super_block *sb, UINT32 sec);
  62
  63 static BUF_CACHE_T *buf_cache_find(struct super_block *sb, UINT32 sec);
  64 static BUF_CACHE_T *buf_cache_get(struct super_block *sb, UINT32 sec);
  65 static void buf_cache_insert_hash(struct super_block *sb, BUF_CACHE_T *bp);
  66 static void buf_cache_remove_hash(BUF_CACHE_T *bp);
  67
  68 static void push_to_mru(BUF_CACHE_T *bp, BUF_CACHE_T *list);
  69 static void push_to_lru(BUF_CACHE_T *bp, BUF_CACHE_T *list);
  70 static void move_to_mru(BUF_CACHE_T *bp, BUF_CACHE_T *list);
  71 static void move_to_lru(BUF_CACHE_T *bp, BUF_CACHE_T *list);
  72
  73 /*======================================================================*/
  74 /*  Cache Initialization Functions                                      */
  75 /*======================================================================*/
  76
  77 INT32 buf_init(struct super_block *sb)
  78 {
  79         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
  80
  81         INT32 i;
  82
  83         /* LRU list */
  84         p_fs->FAT_cache_lru_list.next = p_fs->FAT_cache_lru_list.prev = &p_fs->FAT_cache_lru_list;
  85
  86         for (i = 0; i < FAT_CACHE_SIZE; i++) {
  87                 p_fs->FAT_cache_array[i].drv = -1;
  88                 p_fs->FAT_cache_array[i].sec = ~0;
  89                 p_fs->FAT_cache_array[i].flag = 0;
  90                 p_fs->FAT_cache_array[i].buf_bh = NULL;
  91                 p_fs->FAT_cache_array[i].prev = p_fs->FAT_cache_array[i].next = NULL;
  92                 push_to_mru(&(p_fs->FAT_cache_array[i]), &p_fs->FAT_cache_lru_list);
  93         }
  94
  95         p_fs->buf_cache_lru_list.next = p_fs->buf_cache_lru_list.prev = &p_fs->buf_cache_lru_list;
  96
  97         for (i = 0; i < BUF_CACHE_SIZE; i++) {
  98                 p_fs->buf_cache_array[i].drv = -1;
  99                 p_fs->buf_cache_array[i].sec = ~0;
 100                 p_fs->buf_cache_array[i].flag = 0;
 101                 p_fs->buf_cache_array[i].buf_bh = NULL;
 102                 p_fs->buf_cache_array[i].prev = p_fs->buf_cache_array[i].next = NULL;
 103                 push_to_mru(&(p_fs->buf_cache_array[i]), &p_fs->buf_cache_lru_list);
 104         }
 105
 106         /* HASH list */
 107         for (i = 0; i < FAT_CACHE_HASH_SIZE; i++) {
 108                 p_fs->FAT_cache_hash_list[i].drv = -1;
 109                 p_fs->FAT_cache_hash_list[i].sec = ~0;
 110                 p_fs->FAT_cache_hash_list[i].hash_next = p_fs->FAT_cache_hash_list[i].hash_prev = &(p_fs->FAT_cache_hash_list[i]);
 111         }
 112
 113         for (i = 0; i < FAT_CACHE_SIZE; i++) {
 114                 FAT_cache_insert_hash(sb, &(p_fs->FAT_cache_array[i]));
 115         }
 116
 117         for (i = 0; i < BUF_CACHE_HASH_SIZE; i++) {
 118                 p_fs->buf_cache_hash_list[i].drv = -1;
 119                 p_fs->buf_cache_hash_list[i].sec = ~0;
 120                 p_fs->buf_cache_hash_list[i].hash_next = p_fs->buf_cache_hash_list[i].hash_prev = &(p_fs->buf_cache_hash_list[i]);
 121         }
 122
 123         for (i = 0; i < BUF_CACHE_SIZE; i++) {
 124                 buf_cache_insert_hash(sb, &(p_fs->buf_cache_array[i]));
 125         }
 126
 127         return(FFS_SUCCESS);
 128 } /* end of buf_init */
 129
 130 INT32 buf_shutdown(struct super_block *sb)
 131 {
 132         return(FFS_SUCCESS);
 133 } /* end of buf_shutdown */
 134
 135 /*======================================================================*/
 136 /*  FAT Read/Write Functions                                            */
 137 /*======================================================================*/
 138
 139 /* in : sb, loc
 140   * out: content
 141   * returns 0 on success
 142   *            -1 on error
 143   */
 144 INT32 FAT_read(struct super_block *sb, UINT32 loc, UINT32 *content)
 145 {
 146         INT32 ret;
 147
 148         sm_P(&f_sem);
 149
 150         ret = __FAT_read(sb, loc, content);
 151
 152         sm_V(&f_sem);
 153
 154         return(ret);
 155 } /* end of FAT_read */
 156
 157 INT32 FAT_write(struct super_block *sb, UINT32 loc, UINT32 content)
 158 {
 159         INT32 ret;
 160
 161         sm_P(&f_sem);
 162
 163         ret = __FAT_write(sb, loc, content);
 164
 165         sm_V(&f_sem);
 166
 167         return(ret);
 168 } /* end of FAT_write */
 169
 170 static INT32 __FAT_read(struct super_block *sb, UINT32 loc, UINT32 *content)
 171 {
 172         INT32 off;
 173         UINT32 sec, _content;
 174         UINT8 *fat_sector, *fat_entry;
 175         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 176         BD_INFO_T *p_bd = &(EXFAT_SB(sb)->bd_info);
 177
 178         if (p_fs->vol_type == FAT12) {
 179                 sec = p_fs->FAT1_start_sector + ((loc + (loc >> 1)) >> p_bd->sector_size_bits);
 180                 off = (loc + (loc >> 1)) & p_bd->sector_size_mask;
 181
 182                 if (off == (p_bd->sector_size-1)) {
 183                         fat_sector = FAT_getblk(sb, sec);
 184                         if (!fat_sector)
 185                                 return -1;
 186
 187                         _content  = (UINT32) fat_sector[off];
 188
 189                         fat_sector = FAT_getblk(sb, ++sec);
 190                         if (!fat_sector)
 191                                 return -1;
 192
 193                         _content |= (UINT32) fat_sector[0] << 8;
 194                 } else {
 195                         fat_sector = FAT_getblk(sb, sec);
 196                         if (!fat_sector)
 197                                 return -1;
 198
 199                         fat_entry = &(fat_sector[off]);
 200                         _content = GET16(fat_entry);
 201                 }
 202
 203                 if (loc & 1) _content >>= 4;
 204
 205                 _content &= 0x00000FFF;
 206
 207                 if (_content >= CLUSTER_16(0x0FF8)) {
 208                         *content = CLUSTER_32(~0);
 209                         return 0;
 210                 } else {
 211                         *content = CLUSTER_32(_content);
 212                         return 0;
 213                 }
 214         } else if (p_fs->vol_type == FAT16) {
 215                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-1));
 216                 off = (loc << 1) & p_bd->sector_size_mask;
 217
 218                 fat_sector = FAT_getblk(sb, sec);
 219                 if (!fat_sector)
 220                         return -1;
 221
 222                 fat_entry = &(fat_sector[off]);
 223
 224                 _content = GET16_A(fat_entry);
 225
 226                 _content &= 0x0000FFFF;
 227
 228                 if (_content >= CLUSTER_16(0xFFF8)) {
 229                         *content = CLUSTER_32(~0);
 230                         return 0;
 231                 } else {
 232                         *content = CLUSTER_32(_content);
 233                         return 0;
 234                 }
 235         } else if (p_fs->vol_type == FAT32) {
 236                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-2));
 237                 off = (loc << 2) & p_bd->sector_size_mask;
 238
 239                 fat_sector = FAT_getblk(sb, sec);
 240                 if (!fat_sector)
 241                         return -1;
 242
 243                 fat_entry = &(fat_sector[off]);
 244
 245                 _content = GET32_A(fat_entry);
 246
 247                 _content &= 0x0FFFFFFF;
 248
 249                 if (_content >= CLUSTER_32(0x0FFFFFF8)) {
 250                         *content = CLUSTER_32(~0);
 251                         return 0;
 252                 } else {
 253                         *content = CLUSTER_32(_content);
 254                         return 0;
 255                 }
 256         } else {
 257                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-2));
 258                 off = (loc << 2) & p_bd->sector_size_mask;
 259
 260                 fat_sector = FAT_getblk(sb, sec);
 261                 if (!fat_sector)
 262                         return -1;
 263
 264                 fat_entry = &(fat_sector[off]);
 265                 _content = GET32_A(fat_entry);
 266
 267                 if (_content >= CLUSTER_32(0xFFFFFFF8)) {
 268                         *content = CLUSTER_32(~0);
 269                         return 0;
 270                 } else {
 271                         *content = CLUSTER_32(_content);
 272                         return 0;
 273                 }
 274         }
 275
 276         *content = CLUSTER_32(~0);
 277         return 0;
 278 } /* end of __FAT_read */
 279
 280 static INT32 __FAT_write(struct super_block *sb, UINT32 loc, UINT32 content)
 281 {
 282         INT32 off;
 283         UINT32 sec;
 284         UINT8 *fat_sector, *fat_entry;
 285         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 286         BD_INFO_T *p_bd = &(EXFAT_SB(sb)->bd_info);
 287
 288         if (p_fs->vol_type == FAT12) {
 289
 290                 content &= 0x00000FFF;
 291
 292                 sec = p_fs->FAT1_start_sector + ((loc + (loc >> 1)) >> p_bd->sector_size_bits);
 293                 off = (loc + (loc >> 1)) & p_bd->sector_size_mask;
 294
 295                 fat_sector = FAT_getblk(sb, sec);
 296                 if (!fat_sector)
 297                         return -1;
 298
 299                 if (loc & 1) { /* odd */
 300
 301                         content <<= 4;
 302
 303                         if (off == (p_bd->sector_size-1)) {
 304                                 fat_sector[off] = (UINT8)(content | (fat_sector[off] & 0x0F));
 305                                 FAT_modify(sb, sec);
 306
 307                                 fat_sector = FAT_getblk(sb, ++sec);
 308                                 if (!fat_sector)
 309                                         return -1;
 310
 311                                 fat_sector[0] = (UINT8)(content >> 8);
 312                         } else {
 313                                 fat_entry = &(fat_sector[off]);
 314                                 content |= GET16(fat_entry) & 0x000F;
 315
 316                                 SET16(fat_entry, content);
 317                         }
 318                 } else { /* even */
 319                         fat_sector[off] = (UINT8)(content);
 320
 321                         if (off == (p_bd->sector_size-1)) {
 322                                 fat_sector[off] = (UINT8)(content);
 323                                 FAT_modify(sb, sec);
 324
 325                                 fat_sector = FAT_getblk(sb, ++sec);
 326                                 fat_sector[0] = (UINT8)((fat_sector[0] & 0xF0) | (content >> 8));
 327                         } else {
 328                                 fat_entry = &(fat_sector[off]);
 329                                 content |= GET16(fat_entry) & 0xF000;
 330
 331                                 SET16(fat_entry, content);
 332                         }
 333                 }
 334         }
 335
 336         else if (p_fs->vol_type == FAT16) {
 337
 338                 content &= 0x0000FFFF;
 339
 340                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-1));
 341                 off = (loc << 1) & p_bd->sector_size_mask;
 342
 343                 fat_sector = FAT_getblk(sb, sec);
 344                 if (!fat_sector)
 345                         return -1;
 346
 347                 fat_entry = &(fat_sector[off]);
 348
 349                 SET16_A(fat_entry, content);
 350         }
 351
 352         else if (p_fs->vol_type == FAT32) {
 353
 354                 content &= 0x0FFFFFFF;
 355
 356                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-2));
 357                 off = (loc << 2) & p_bd->sector_size_mask;
 358
 359                 fat_sector = FAT_getblk(sb, sec);
 360                 if (!fat_sector)
 361                         return -1;
 362
 363                 fat_entry = &(fat_sector[off]);
 364
 365                 content |= GET32_A(fat_entry) & 0xF0000000;
 366
 367                 SET32_A(fat_entry, content);
 368         }
 369
 370         else { /* p_fs->vol_type == EXFAT */
 371
 372                 sec = p_fs->FAT1_start_sector + (loc >> (p_bd->sector_size_bits-2));
 373                 off = (loc << 2) & p_bd->sector_size_mask;
 374
 375                 fat_sector = FAT_getblk(sb, sec);
 376                 if (!fat_sector)
 377                         return -1;
 378
 379                 fat_entry = &(fat_sector[off]);
 380
 381                 SET32_A(fat_entry, content);
 382         }
 383
 384         FAT_modify(sb, sec);
 385         return 0;
 386 } /* end of __FAT_write */
 387
 388 UINT8 *FAT_getblk(struct super_block *sb, UINT32 sec)
 389 {
 390         BUF_CACHE_T *bp;
 391         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 392
 393         bp = FAT_cache_find(sb, sec);
 394         if (bp != NULL) {
 395                 move_to_mru(bp, &p_fs->FAT_cache_lru_list);
 396                 return(bp->buf_bh->b_data);
 397         }
 398
 399         bp = FAT_cache_get(sb, sec);
 400
 401         FAT_cache_remove_hash(bp);
 402
 403         bp->drv = p_fs->drv;
 404         bp->sec = sec;
 405         bp->flag = 0;
 406
 407         FAT_cache_insert_hash(sb, bp);
 408
 409         if (sector_read(sb, sec, &(bp->buf_bh), 1) != FFS_SUCCESS) {
 410                 FAT_cache_remove_hash(bp);
 411                 bp->drv = -1;
 412                 bp->sec = ~0;
 413                 bp->flag = 0;
 414                 bp->buf_bh = NULL;
 415
 416                 move_to_lru(bp, &p_fs->FAT_cache_lru_list);
 417                 return NULL;
 418         }
 419
 420         return(bp->buf_bh->b_data);
 421 } /* end of FAT_getblk */
 422
 423 void FAT_modify(struct super_block *sb, UINT32 sec)
 424 {
 425         BUF_CACHE_T *bp;
 426
 427         bp = FAT_cache_find(sb, sec);
 428         if (bp != NULL) {
 429                 sector_write(sb, sec, bp->buf_bh, 0);
 430         }
 431 } /* end of FAT_modify */
 432
 433 void FAT_release_all(struct super_block *sb)
 434 {
 435         BUF_CACHE_T *bp;
 436         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 437
 438         sm_P(&f_sem);
 439
 440         bp = p_fs->FAT_cache_lru_list.next;
 441         while (bp != &p_fs->FAT_cache_lru_list) {
 442                 if (bp->drv == p_fs->drv) {
 443                         bp->drv = -1;
 444                         bp->sec = ~0;
 445                         bp->flag = 0;
 446
 447                         if(bp->buf_bh) {
 448                                 __brelse(bp->buf_bh);
 449                                 bp->buf_bh = NULL;
 450                         }
 451                 }
 452                 bp = bp->next;
 453         }
 454
 455         sm_V(&f_sem);
 456 } /* end of FAT_release_all */
 457
 458 void FAT_sync(struct super_block *sb)
 459 {
 460         BUF_CACHE_T *bp;
 461         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 462
 463         sm_P(&f_sem);
 464
 465         bp = p_fs->FAT_cache_lru_list.next;
 466         while (bp != &p_fs->FAT_cache_lru_list) {
 467                 if ((bp->drv == p_fs->drv) && (bp->flag & DIRTYBIT)) {
 468                         sync_dirty_buffer(bp->buf_bh);
 469                         bp->flag &= ~(DIRTYBIT);
 470                 }
 471                 bp = bp->next;
 472         }
 473
 474         sm_V(&f_sem);
 475 } /* end of FAT_sync */
 476
 477 static BUF_CACHE_T *FAT_cache_find(struct super_block *sb, UINT32 sec)
 478 {
 479         INT32 off;
 480         BUF_CACHE_T *bp, *hp;
 481         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 482
 483         off = (sec + (sec >> p_fs->sectors_per_clu_bits)) & (FAT_CACHE_HASH_SIZE - 1);
 484
 485         hp = &(p_fs->FAT_cache_hash_list[off]);
 486         for (bp = hp->hash_next; bp != hp; bp = bp->hash_next) {
 487                 if ((bp->drv == p_fs->drv) && (bp->sec == sec)) {
 488
 489                         WARN(!bp->buf_bh, "[EXFAT] FAT_cache has no bh. "
 490                                           "It will make system panic.\n");
 491
 492                         touch_buffer(bp->buf_bh);
 493                         return(bp);
 494                 }
 495         }
 496         return(NULL);
 497 } /* end of FAT_cache_find */
 498
 499 static BUF_CACHE_T *FAT_cache_get(struct super_block *sb, UINT32 sec)
 500 {
 501         BUF_CACHE_T *bp;
 502         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 503
 504         bp = p_fs->FAT_cache_lru_list.prev;
 505
 506
 507         move_to_mru(bp, &p_fs->FAT_cache_lru_list);
 508         return(bp);
 509 } /* end of FAT_cache_get */
 510
 511 static void FAT_cache_insert_hash(struct super_block *sb, BUF_CACHE_T *bp)
 512 {
 513         INT32 off;
 514         BUF_CACHE_T *hp;
 515         FS_INFO_T *p_fs;
 516
 517         p_fs = &(EXFAT_SB(sb)->fs_info);
 518         off = (bp->sec + (bp->sec >> p_fs->sectors_per_clu_bits)) & (FAT_CACHE_HASH_SIZE-1);
 519
 520         hp = &(p_fs->FAT_cache_hash_list[off]);
 521         bp->hash_next = hp->hash_next;
 522         bp->hash_prev = hp;
 523         hp->hash_next->hash_prev = bp;
 524         hp->hash_next = bp;
 525 } /* end of FAT_cache_insert_hash */
 526
 527 static void FAT_cache_remove_hash(BUF_CACHE_T *bp)
 528 {
 529         (bp->hash_prev)->hash_next = bp->hash_next;
 530         (bp->hash_next)->hash_prev = bp->hash_prev;
 531 } /* end of FAT_cache_remove_hash */
 532
 533 /*======================================================================*/
 534 /*  Buffer Read/Write Functions                                         */
 535 /*======================================================================*/
 536
 537 UINT8 *buf_getblk(struct super_block *sb, UINT32 sec)
 538 {
 539         UINT8 *buf;
 540
 541         sm_P(&b_sem);
 542
 543         buf = __buf_getblk(sb, sec);
 544
 545         sm_V(&b_sem);
 546
 547         return(buf);
 548 } /* end of buf_getblk */
 549
 550 static UINT8 *__buf_getblk(struct super_block *sb, UINT32 sec)
 551 {
 552         BUF_CACHE_T *bp;
 553         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 554
 555         bp = buf_cache_find(sb, sec);
 556         if (bp != NULL) {
 557                 move_to_mru(bp, &p_fs->buf_cache_lru_list);
 558                 return(bp->buf_bh->b_data);
 559         }
 560
 561         bp = buf_cache_get(sb, sec);
 562
 563         buf_cache_remove_hash(bp);
 564
 565         bp->drv = p_fs->drv;
 566         bp->sec = sec;
 567         bp->flag = 0;
 568
 569         buf_cache_insert_hash(sb, bp);
 570
 571         if (sector_read(sb, sec, &(bp->buf_bh), 1) != FFS_SUCCESS) {
 572                 buf_cache_remove_hash(bp);
 573                 bp->drv = -1;
 574                 bp->sec = ~0;
 575                 bp->flag = 0;
 576                 bp->buf_bh = NULL;
 577
 578                 move_to_lru(bp, &p_fs->buf_cache_lru_list);
 579                 return NULL;
 580         }
 581
 582         return(bp->buf_bh->b_data);
 583
 584 } /* end of __buf_getblk */
 585
 586 void buf_modify(struct super_block *sb, UINT32 sec)
 587 {
 588         BUF_CACHE_T *bp;
 589
 590         sm_P(&b_sem);
 591
 592         bp = buf_cache_find(sb, sec);
 593         if (likely(bp != NULL)) {
 594                 sector_write(sb, sec, bp->buf_bh, 0);
 595         }
 596
 597         WARN(!bp, "[EXFAT] failed to find buffer_cache(sector:%u).\n", sec);
 598
 599         sm_V(&b_sem);
 600 } /* end of buf_modify */
 601
 602 void buf_lock(struct super_block *sb, UINT32 sec)
 603 {
 604         BUF_CACHE_T *bp;
 605
 606         sm_P(&b_sem);
 607
 608         bp = buf_cache_find(sb, sec);
 609         if (likely(bp != NULL)) bp->flag |= LOCKBIT;
 610
 611         WARN(!bp, "[EXFAT] failed to find buffer_cache(sector:%u).\n", sec);
 612
 613         sm_V(&b_sem);
 614 } /* end of buf_lock */
 615
 616 void buf_unlock(struct super_block *sb, UINT32 sec)
 617 {
 618         BUF_CACHE_T *bp;
 619
 620         sm_P(&b_sem);
 621
 622         bp = buf_cache_find(sb, sec);
 623         if (likely(bp != NULL)) bp->flag &= ~(LOCKBIT);
 624
 625         WARN(!bp, "[EXFAT] failed to find buffer_cache(sector:%u).\n", sec);
 626
 627         sm_V(&b_sem);
 628 } /* end of buf_unlock */
 629
 630 void buf_release(struct super_block *sb, UINT32 sec)
 631 {
 632         BUF_CACHE_T *bp;
 633         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 634
 635         sm_P(&b_sem);
 636
 637         bp = buf_cache_find(sb, sec);
 638         if (likely(bp != NULL)) {
 639                 bp->drv = -1;
 640                 bp->sec = ~0;
 641                 bp->flag = 0;
 642
 643                 if(bp->buf_bh) {
 644                         __brelse(bp->buf_bh);
 645                         bp->buf_bh = NULL;
 646                 }
 647
 648                 move_to_lru(bp, &p_fs->buf_cache_lru_list);
 649         }
 650
 651         sm_V(&b_sem);
 652 } /* end of buf_release */
 653
 654 void buf_release_all(struct super_block *sb)
 655 {
 656         BUF_CACHE_T *bp;
 657         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 658
 659         sm_P(&b_sem);
 660
 661         bp = p_fs->buf_cache_lru_list.next;
 662         while (bp != &p_fs->buf_cache_lru_list) {
 663                 if (bp->drv == p_fs->drv) {
 664                         bp->drv = -1;
 665                         bp->sec = ~0;
 666                         bp->flag = 0;
 667
 668                         if(bp->buf_bh) {
 669                                 __brelse(bp->buf_bh);
 670                                 bp->buf_bh = NULL;
 671                         }
 672                 }
 673                 bp = bp->next;
 674         }
 675
 676         sm_V(&b_sem);
 677 } /* end of buf_release_all */
 678
 679 void buf_sync(struct super_block *sb)
 680 {
 681         BUF_CACHE_T *bp;
 682         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 683
 684         sm_P(&b_sem);
 685
 686         bp = p_fs->buf_cache_lru_list.next;
 687         while (bp != &p_fs->buf_cache_lru_list) {
 688                 if ((bp->drv == p_fs->drv) && (bp->flag & DIRTYBIT)) {
 689                         sync_dirty_buffer(bp->buf_bh);
 690                         bp->flag &= ~(DIRTYBIT);
 691                 }
 692                 bp = bp->next;
 693         }
 694
 695         sm_V(&b_sem);
 696 } /* end of buf_sync */
 697
 698 static BUF_CACHE_T *buf_cache_find(struct super_block *sb, UINT32 sec)
 699 {
 700         INT32 off;
 701         BUF_CACHE_T *bp, *hp;
 702         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 703
 704         off = (sec + (sec >> p_fs->sectors_per_clu_bits)) & (BUF_CACHE_HASH_SIZE - 1);
 705
 706         hp = &(p_fs->buf_cache_hash_list[off]);
 707         for (bp = hp->hash_next; bp != hp; bp = bp->hash_next) {
 708                 if ((bp->drv == p_fs->drv) && (bp->sec == sec)) {
 709                         touch_buffer(bp->buf_bh);
 710                         return(bp);
 711                 }
 712         }
 713         return(NULL);
 714 } /* end of buf_cache_find */
 715
 716 static BUF_CACHE_T *buf_cache_get(struct super_block *sb, UINT32 sec)
 717 {
 718         BUF_CACHE_T *bp;
 719         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 720
 721         bp = p_fs->buf_cache_lru_list.prev;
 722         while (bp->flag & LOCKBIT) bp = bp->prev;
 723
 724
 725         move_to_mru(bp, &p_fs->buf_cache_lru_list);
 726         return(bp);
 727 } /* end of buf_cache_get */
 728
 729 static void buf_cache_insert_hash(struct super_block *sb, BUF_CACHE_T *bp)
 730 {
 731         INT32 off;
 732         BUF_CACHE_T *hp;
 733         FS_INFO_T *p_fs;
 734
 735         p_fs = &(EXFAT_SB(sb)->fs_info);
 736         off = (bp->sec + (bp->sec >> p_fs->sectors_per_clu_bits)) & (BUF_CACHE_HASH_SIZE-1);
 737
 738         hp = &(p_fs->buf_cache_hash_list[off]);
 739         bp->hash_next = hp->hash_next;
 740         bp->hash_prev = hp;
 741         hp->hash_next->hash_prev = bp;
 742         hp->hash_next = bp;
 743 } /* end of buf_cache_insert_hash */
 744
 745 static void buf_cache_remove_hash(BUF_CACHE_T *bp)
 746 {
 747         (bp->hash_prev)->hash_next = bp->hash_next;
 748         (bp->hash_next)->hash_prev = bp->hash_prev;
 749 } /* end of buf_cache_remove_hash */
 750
 751 /*======================================================================*/
 752 /*  Local Function Definitions                                          */
 753 /*======================================================================*/
 754
 755 static void push_to_mru(BUF_CACHE_T *bp, BUF_CACHE_T *list)
 756 {
 757         bp->next = list->next;
 758         bp->prev = list;
 759         list->next->prev = bp;
 760         list->next = bp;
 761 } /* end of buf_cache_push_to_mru */
 762
 763 static void push_to_lru(BUF_CACHE_T *bp, BUF_CACHE_T *list)
 764 {
 765         bp->prev = list->prev;
 766         bp->next = list;
 767         list->prev->next = bp;
 768         list->prev = bp;
 769 } /* end of buf_cache_push_to_lru */
 770
 771 static void move_to_mru(BUF_CACHE_T *bp, BUF_CACHE_T *list)
 772 {
 773         bp->prev->next = bp->next;
 774         bp->next->prev = bp->prev;
 775         push_to_mru(bp, list);
 776 } /* end of buf_cache_move_to_mru */
 777
 778 static void move_to_lru(BUF_CACHE_T *bp, BUF_CACHE_T *list)
 779 {
 780         bp->prev->next = bp->next;
 781         bp->next->prev = bp->prev;
 782         push_to_lru(bp, list);
 783 } /* end of buf_cache_move_to_lru */
 784
 785 /* end of exfat_cache.c */