release/src-rt/linux/linux-2.6/fs/exfat/exfat_api.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_api.c                                               */
  23 /*  PURPOSE : exFAT API Glue Layer                                      */
  24 /*                                                                      */
  25 /*----------------------------------------------------------------------*/
  26 /*  NOTES                                                               */
  27 /*                                                                      */
  28 /*----------------------------------------------------------------------*/
  29 /*  REVISION HISTORY (Ver 0.9)                                          */
  30 /*                                                                      */
  31 /*  - 2010.11.15 [Joosun Hahn] : first writing                          */
  32 /*                                                                      */
  33 /************************************************************************/
  34
  35 #include <linux/version.h>
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38
  39 #include "exfat_version.h"
  40 #include "exfat_config.h"
  41 #include "exfat_global.h"
  42 #include "exfat_data.h"
  43 #include "exfat_oal.h"
  44
  45 #include "exfat_part.h"
  46 #include "exfat_nls.h"
  47 #include "exfat_api.h"
  48 #include "exfat_super.h"
  49 #include "exfat.h"
  50
  51 /*----------------------------------------------------------------------*/
  52 /*  Constant & Macro Definitions                                        */
  53 /*----------------------------------------------------------------------*/
  54
  55 /*----------------------------------------------------------------------*/
  56 /*  Global Variable Definitions                                         */
  57 /*----------------------------------------------------------------------*/
  58
  59 extern FS_STRUCT_T      fs_struct[];
  60
  61 extern struct semaphore z_sem;
  62
  63 /*----------------------------------------------------------------------*/
  64 /*  Local Variable Definitions                                          */
  65 /*----------------------------------------------------------------------*/
  66
  67 /*----------------------------------------------------------------------*/
  68 /*  Local Function Declarations                                         */
  69 /*----------------------------------------------------------------------*/
  70
  71 /*======================================================================*/
  72 /*  Global Function Definitions                                         */
  73 /*    - All functions for global use have same return value format,     */
  74 /*      that is, FFS_SUCCESS on success and several FS error code on    */
  75 /*      various error condition.                                        */
  76 /*======================================================================*/
  77
  78 /*----------------------------------------------------------------------*/
  79 /*  exFAT Filesystem Init & Exit Functions                              */
  80 /*----------------------------------------------------------------------*/
  81
  82 INT32 FsInit(void)
  83 {
  84   INT32 i;
  85
  86         /* initialize all volumes as un-mounted */
  87         for (i = 0; i < MAX_DRIVE; i++) {
  88                 fs_struct[i].mounted = FALSE;
  89                 fs_struct[i].sb = NULL;
  90                 sm_init(&(fs_struct[i].v_sem));
  91         }
  92
  93         return(ffsInit());
  94 }
  95
  96 INT32 FsShutdown(void)
  97 {
  98         INT32 i;
  99
 100         /* unmount all volumes */
 101         for (i = 0; i < MAX_DRIVE; i++) {
 102                 if (!fs_struct[i].mounted) continue;
 103
 104                 ffsUmountVol(fs_struct[i].sb);
 105         }
 106
 107         return(ffsShutdown());
 108 }
 109
 110 /*----------------------------------------------------------------------*/
 111 /*  Volume Management Functions                                         */
 112 /*----------------------------------------------------------------------*/
 113
 114 /* FsMountVol : mount the file system volume */
 115 INT32 FsMountVol(struct super_block *sb)
 116 {
 117         INT32 err, drv;
 118
 119         sm_P(&z_sem);
 120
 121         for (drv = 0; drv < MAX_DRIVE; drv++) {
 122                 if (!fs_struct[drv].mounted) break;
 123         }
 124
 125         if (drv >= MAX_DRIVE) return(FFS_ERROR);
 126
 127         /* acquire the lock for file system critical section */
 128         sm_P(&(fs_struct[drv].v_sem));
 129
 130         err = buf_init(sb);
 131         if (!err) {
 132                 err = ffsMountVol(sb, drv);
 133         }
 134
 135         /* release the lock for file system critical section */
 136         sm_V(&(fs_struct[drv].v_sem));
 137
 138         if (!err) {
 139                 fs_struct[drv].mounted = TRUE;
 140                 fs_struct[drv].sb = sb;
 141         } else {
 142                 buf_shutdown(sb);
 143         }
 144
 145         sm_V(&z_sem);
 146
 147         return(err);
 148 } /* end of FsMountVol */
 149
 150 /* FsUmountVol : unmount the file system volume */
 151 INT32 FsUmountVol(struct super_block *sb)
 152 {
 153         INT32 err;
 154         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 155
 156         sm_P(&z_sem);
 157
 158         /* acquire the lock for file system critical section */
 159         sm_P(&(fs_struct[p_fs->drv].v_sem));
 160
 161         err = ffsUmountVol(sb);
 162         buf_shutdown(sb);
 163
 164         /* release the lock for file system critical section */
 165         sm_V(&(fs_struct[p_fs->drv].v_sem));
 166
 167         fs_struct[p_fs->drv].mounted = FALSE;
 168         fs_struct[p_fs->drv].sb = NULL;
 169
 170         sm_V(&z_sem);
 171
 172         return(err);
 173 } /* end of FsUmountVol */
 174
 175 /* FsGetVolInfo : get the information of a file system volume */
 176 INT32 FsGetVolInfo(struct super_block *sb, VOL_INFO_T *info)
 177 {
 178         INT32 err;
 179         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 180
 181         /* check the validity of pointer parameters */
 182         if (info == NULL) return(FFS_ERROR);
 183
 184         /* acquire the lock for file system critical section */
 185         sm_P(&(fs_struct[p_fs->drv].v_sem));
 186
 187         err = ffsGetVolInfo(sb, info);
 188
 189         /* release the lock for file system critical section */
 190         sm_V(&(fs_struct[p_fs->drv].v_sem));
 191
 192         return(err);
 193 } /* end of FsGetVolInfo */
 194
 195 /* FsSyncVol : synchronize a file system volume */
 196 INT32 FsSyncVol(struct super_block *sb, INT32 do_sync)
 197 {
 198         INT32 err;
 199         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 200
 201         /* acquire the lock for file system critical section */
 202         sm_P(&(fs_struct[p_fs->drv].v_sem));
 203
 204         err = ffsSyncVol(sb, do_sync);
 205
 206         /* release the lock for file system critical section */
 207         sm_V(&(fs_struct[p_fs->drv].v_sem));
 208
 209         return(err);
 210 } /* end of FsSyncVol */
 211
 212
 213 /*----------------------------------------------------------------------*/
 214 /*  File Operation Functions                                            */
 215 /*----------------------------------------------------------------------*/
 216
 217 /* FsCreateFile : create a file */
 218 INT32 FsLookupFile(struct inode *inode, UINT8 *path, FILE_ID_T *fid)
 219 {
 220         INT32 err;
 221         struct super_block *sb = inode->i_sb;
 222         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 223
 224         /* check the validity of pointer parameters */
 225         if ((fid == NULL) || (path == NULL) || (*path == '\0'))
 226                 return(FFS_ERROR);
 227
 228         /* acquire the lock for file system critical section */
 229         sm_P(&(fs_struct[p_fs->drv].v_sem));
 230
 231         err = ffsLookupFile(inode, path, fid);
 232
 233         /* release the lock for file system critical section */
 234         sm_V(&(fs_struct[p_fs->drv].v_sem));
 235
 236         return(err);
 237 } /* end of FsLookupFile */
 238
 239 /* FsCreateFile : create a file */
 240 INT32 FsCreateFile(struct inode *inode, UINT8 *path, UINT8 mode, FILE_ID_T *fid)
 241 {
 242         INT32 err;
 243         struct super_block *sb = inode->i_sb;
 244         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 245
 246         /* check the validity of pointer parameters */
 247         if ((fid == NULL) || (path == NULL) || (*path == '\0'))
 248                 return(FFS_ERROR);
 249
 250         /* acquire the lock for file system critical section */
 251         sm_P(&(fs_struct[p_fs->drv].v_sem));
 252
 253         err = ffsCreateFile(inode, path, mode, fid);
 254
 255         /* release the lock for file system critical section */
 256         sm_V(&(fs_struct[p_fs->drv].v_sem));
 257
 258         return(err);
 259 } /* end of FsCreateFile */
 260
 261 INT32 FsReadFile(struct inode *inode, FILE_ID_T *fid, void *buffer, UINT64 count, UINT64 *rcount)
 262 {
 263         INT32 err;
 264         struct super_block *sb = inode->i_sb;
 265         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 266
 267         /* check the validity of the given file id */
 268         if (fid == NULL) return(FFS_INVALIDFID);
 269
 270         /* check the validity of pointer parameters */
 271         if (buffer == NULL) return(FFS_ERROR);
 272
 273         /* acquire the lock for file system critical section */
 274         sm_P(&(fs_struct[p_fs->drv].v_sem));
 275
 276         err = ffsReadFile(inode, fid, buffer, count, rcount);
 277
 278         /* release the lock for file system critical section */
 279         sm_V(&(fs_struct[p_fs->drv].v_sem));
 280
 281         return(err);
 282 } /* end of FsReadFile */
 283
 284 INT32 FsWriteFile(struct inode *inode, FILE_ID_T *fid, void *buffer, UINT64 count, UINT64 *wcount)
 285 {
 286         INT32 err;
 287         struct super_block *sb = inode->i_sb;
 288         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 289
 290         /* check the validity of the given file id */
 291         if (fid == NULL) return(FFS_INVALIDFID);
 292
 293         /* check the validity of pointer parameters */
 294         if (buffer == NULL) return(FFS_ERROR);
 295
 296         /* acquire the lock for file system critical section */
 297         sm_P(&(fs_struct[p_fs->drv].v_sem));
 298
 299         err = ffsWriteFile(inode, fid, buffer, count, wcount);
 300
 301         /* release the lock for file system critical section */
 302         sm_V(&(fs_struct[p_fs->drv].v_sem));
 303
 304         return(err);
 305 } /* end of FsWriteFile */
 306
 307 /* FsTruncateFile : resize the file length */
 308 INT32 FsTruncateFile(struct inode *inode, UINT64 old_size, UINT64 new_size)
 309 {
 310         INT32 err;
 311         struct super_block *sb = inode->i_sb;
 312         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 313
 314         /* acquire the lock for file system critical section */
 315         sm_P(&(fs_struct[p_fs->drv].v_sem));
 316
 317         PRINTK("FsTruncateFile entered (inode %p size %llu)\n", inode, new_size);
 318
 319         err = ffsTruncateFile(inode, old_size, new_size);
 320
 321         PRINTK("FsTruncateFile exitted (%d)\n", err);
 322
 323         /* release the lock for file system critical section */
 324         sm_V(&(fs_struct[p_fs->drv].v_sem));
 325
 326         return(err);
 327 } /* end of FsTruncateFile */
 328
 329 /* FsMoveFile : move(rename) a old file into a new file */
 330 INT32 FsMoveFile(struct inode *old_parent_inode, FILE_ID_T *fid, struct inode *new_parent_inode, struct dentry *new_dentry)
 331 {
 332         INT32 err;
 333         struct super_block *sb = old_parent_inode->i_sb;
 334         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 335
 336         /* check the validity of the given file id */
 337         if (fid == NULL) return(FFS_INVALIDFID);
 338
 339         /* acquire the lock for file system critical section */
 340         sm_P(&(fs_struct[p_fs->drv].v_sem));
 341
 342         err = ffsMoveFile(old_parent_inode, fid, new_parent_inode, new_dentry);
 343
 344         /* release the lock for file system critical section */
 345         sm_V(&(fs_struct[p_fs->drv].v_sem));
 346
 347         return(err);
 348 } /* end of FsMoveFile */
 349
 350 /* FsRemoveFile : remove a file */
 351 INT32 FsRemoveFile(struct inode *inode, FILE_ID_T *fid)
 352 {
 353         INT32 err;
 354         struct super_block *sb = inode->i_sb;
 355         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 356
 357         /* check the validity of the given file id */
 358         if (fid == NULL) return(FFS_INVALIDFID);
 359
 360         /* acquire the lock for file system critical section */
 361         sm_P(&(fs_struct[p_fs->drv].v_sem));
 362
 363         err = ffsRemoveFile(inode, fid);
 364
 365         /* release the lock for file system critical section */
 366         sm_V(&(fs_struct[p_fs->drv].v_sem));
 367
 368         return(err);
 369 } /* end of FsRemoveFile */
 370
 371 /* FsSetAttr : set the attribute of a given file */
 372 INT32 FsSetAttr(struct inode *inode, UINT32 attr)
 373 {
 374         INT32 err;
 375         struct super_block *sb = inode->i_sb;
 376         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 377
 378         /* acquire the lock for file system critical section */
 379         sm_P(&(fs_struct[p_fs->drv].v_sem));
 380
 381         err = ffsSetAttr(inode, attr);
 382
 383         /* release the lock for file system critical section */
 384         sm_V(&(fs_struct[p_fs->drv].v_sem));
 385
 386         return(err);
 387 } /* end of FsSetAttr */
 388
 389 /* FsReadStat : get the information of a given file */
 390 INT32 FsReadStat(struct inode *inode, DIR_ENTRY_T *info)
 391 {
 392         INT32 err;
 393         struct super_block *sb = inode->i_sb;
 394         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 395
 396         /* acquire the lock for file system critical section */
 397         sm_P(&(fs_struct[p_fs->drv].v_sem));
 398
 399         err = ffsGetStat(inode, info);
 400
 401         /* release the lock for file system critical section */
 402         sm_V(&(fs_struct[p_fs->drv].v_sem));
 403
 404         return(err);
 405 } /* end of FsReadStat */
 406
 407 /* FsWriteStat : set the information of a given file */
 408 INT32 FsWriteStat(struct inode *inode, DIR_ENTRY_T *info)
 409 {
 410         INT32 err;
 411         struct super_block *sb = inode->i_sb;
 412         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 413
 414         /* acquire the lock for file system critical section */
 415         sm_P(&(fs_struct[p_fs->drv].v_sem));
 416
 417         PRINTK("FsWriteStat entered (inode %p info %p\n", inode, info);
 418
 419         err = ffsSetStat(inode, info);
 420
 421         /* release the lock for file system critical section */
 422         sm_V(&(fs_struct[p_fs->drv].v_sem));
 423
 424         PRINTK("FsWriteStat exited (%d)\n", err);
 425
 426         return(err);
 427 } /* end of FsWriteStat */
 428
 429 /* FsMapCluster : return the cluster number in the given cluster offset */
 430 INT32 FsMapCluster(struct inode *inode, INT32 clu_offset, UINT32 *clu)
 431 {
 432         INT32 err;
 433         struct super_block *sb = inode->i_sb;
 434         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 435
 436         /* check the validity of pointer parameters */
 437         if (clu == NULL) return(FFS_ERROR);
 438
 439         /* acquire the lock for file system critical section */
 440         sm_P(&(fs_struct[p_fs->drv].v_sem));
 441
 442         err = ffsMapCluster(inode, clu_offset, clu);
 443
 444         /* release the lock for file system critical section */
 445         sm_V(&(fs_struct[p_fs->drv].v_sem));
 446
 447         return(err);
 448 } /* end of FsMapCluster */
 449
 450 /*----------------------------------------------------------------------*/
 451 /*  Directory Operation Functions                                       */
 452 /*----------------------------------------------------------------------*/
 453
 454 /* FsCreateDir : create(make) a directory */
 455 INT32 FsCreateDir(struct inode *inode, UINT8 *path, FILE_ID_T *fid)
 456 {
 457         INT32 err;
 458         struct super_block *sb = inode->i_sb;
 459         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 460
 461         /* check the validity of pointer parameters */
 462         if ((fid == NULL) || (path == NULL) || (*path == '\0'))
 463                 return(FFS_ERROR);
 464
 465         /* acquire the lock for file system critical section */
 466         sm_P(&(fs_struct[p_fs->drv].v_sem));
 467
 468         err = ffsCreateDir(inode, path, fid);
 469
 470         /* release the lock for file system critical section */
 471         sm_V(&(fs_struct[p_fs->drv].v_sem));
 472
 473         return(err);
 474 } /* end of FsCreateDir */
 475
 476 /* FsReadDir : read a directory entry from the opened directory */
 477 INT32 FsReadDir(struct inode *inode, DIR_ENTRY_T *dir_entry)
 478 {
 479         INT32 err;
 480         struct super_block *sb = inode->i_sb;
 481         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 482
 483         /* check the validity of pointer parameters */
 484         if (dir_entry == NULL) return(FFS_ERROR);
 485
 486         /* acquire the lock for file system critical section */
 487         sm_P(&(fs_struct[p_fs->drv].v_sem));
 488
 489         err = ffsReadDir(inode, dir_entry);
 490
 491         /* release the lock for file system critical section */
 492         sm_V(&(fs_struct[p_fs->drv].v_sem));
 493
 494         return(err);
 495 } /* end of FsReadDir */
 496
 497 /* FsRemoveDir : remove a directory */
 498 INT32 FsRemoveDir(struct inode *inode, FILE_ID_T *fid)
 499 {
 500         INT32 err;
 501         struct super_block *sb = inode->i_sb;
 502         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 503
 504         /* check the validity of the given file id */
 505         if (fid == NULL) return(FFS_INVALIDFID);
 506
 507         /* acquire the lock for file system critical section */
 508         sm_P(&(fs_struct[p_fs->drv].v_sem));
 509
 510         err = ffsRemoveDir(inode, fid);
 511
 512         /* release the lock for file system critical section */
 513         sm_V(&(fs_struct[p_fs->drv].v_sem));
 514
 515         return(err);
 516 } /* end of FsRemoveDir */
 517
 518 EXPORT_SYMBOL(FsMountVol);
 519 EXPORT_SYMBOL(FsUmountVol);
 520 EXPORT_SYMBOL(FsGetVolInfo);
 521 EXPORT_SYMBOL(FsSyncVol);
 522 EXPORT_SYMBOL(FsLookupFile);
 523 EXPORT_SYMBOL(FsCreateFile);
 524 EXPORT_SYMBOL(FsReadFile);
 525 EXPORT_SYMBOL(FsWriteFile);
 526 EXPORT_SYMBOL(FsTruncateFile);
 527 EXPORT_SYMBOL(FsMoveFile);
 528 EXPORT_SYMBOL(FsRemoveFile);
 529 EXPORT_SYMBOL(FsSetAttr);
 530 EXPORT_SYMBOL(FsReadStat);
 531 EXPORT_SYMBOL(FsWriteStat);
 532 EXPORT_SYMBOL(FsMapCluster);
 533 EXPORT_SYMBOL(FsCreateDir);
 534 EXPORT_SYMBOL(FsReadDir);
 535 EXPORT_SYMBOL(FsRemoveDir);
 536
 537 #if EXFAT_CONFIG_KERNEL_DEBUG
 538 /* FsReleaseCache: Release FAT & buf cache */
 539 INT32 FsReleaseCache(struct super_block *sb)
 540 {
 541         FS_INFO_T *p_fs = &(EXFAT_SB(sb)->fs_info);
 542
 543         /* acquire the lock for file system critical section */
 544         sm_P(&(fs_struct[p_fs->drv].v_sem));
 545
 546         FAT_release_all(sb);
 547         buf_release_all(sb);
 548
 549         /* release the lock for file system critical section */
 550         sm_V(&(fs_struct[p_fs->drv].v_sem));
 551
 552         return 0;
 553 }
 554 /* FsReleaseCache */
 555
 556 EXPORT_SYMBOL(FsReleaseCache);
 557 #endif /* EXFAT_CONFIG_KERNEL_DEBUG */
 558
 559 /*======================================================================*/
 560 /*  Local Function Definitions                                          */
 561 /*======================================================================*/
 562
 563 /* end of exfat_api.c */