libogc/isfs.c

   1 /*-------------------------------------------------------------
   2
   3 es.c -- ETicket services
   4
   5 Copyright (C) 2008
   6 Michael Wiedenbauer (shagkur)
   7 Dave Murphy (WinterMute)
   8 Hector Martin (marcan)
   9
  10 This software is provided 'as-is', without any express or implied
  11 warranty.  In no event will the authors be held liable for any
  12 damages arising from the use of this software.
  13
  14 Permission is granted to anyone to use this software for any
  15 purpose, including commercial applications, and to alter it and
  16 redistribute it freely, subject to the following restrictions:
  17
  18 1.      The origin of this software must not be misrepresented; you
  19 must not claim that you wrote the original software. If you use
  20 this software in a product, an acknowledgment in the product
  21 documentation would be appreciated but is not required.
  22
  23 2.      Altered source versions must be plainly marked as such, and
  24 must not be misrepresented as being the original software.
  25
  26 3.      This notice may not be removed or altered from any source
  27 distribution.
  28
  29 -------------------------------------------------------------*/
  30
  31 #if defined(HW_RVL)
  32
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <malloc.h>
  37 #include <time.h>
  38 #include <gcutil.h>
  39 #include <ipc.h>
  40
  41 #include "isfs.h"
  42
  43 #define ISFS_STRUCTSIZE                         (sizeof(struct isfs_cb))
  44 #define ISFS_HEAPSIZE                           (ISFS_STRUCTSIZE<<4)
  45
  46 #define ISFS_FUNCNULL                           0
  47 #define ISFS_FUNCGETSTAT                        1
  48 #define ISFS_FUNCREADDIR                        2
  49 #define ISFS_FUNCGETATTR                        3
  50 #define ISFS_FUNCGETUSAGE                       4
  51
  52 #define ISFS_IOCTL_FORMAT                       1
  53 #define ISFS_IOCTL_GETSTATS                     2
  54 #define ISFS_IOCTL_CREATEDIR            3
  55 #define ISFS_IOCTL_READDIR                      4
  56 #define ISFS_IOCTL_SETATTR                      5
  57 #define ISFS_IOCTL_GETATTR                      6
  58 #define ISFS_IOCTL_DELETE                       7
  59 #define ISFS_IOCTL_RENAME                       8
  60 #define ISFS_IOCTL_CREATEFILE           9
  61 #define ISFS_IOCTL_SETFILEVERCTRL       10
  62 #define ISFS_IOCTL_GETFILESTATS         11
  63 #define ISFS_IOCTL_GETUSAGE                     12
  64 #define ISFS_IOCTL_SHUTDOWN                     13
  65
  66 struct isfs_cb
  67 {
  68         char filepath[ISFS_MAXPATH];
  69         union {
  70                 struct {
  71                         char filepathOld[ISFS_MAXPATH];
  72                         char filepathNew[ISFS_MAXPATH];
  73                 } fsrename;
  74                 struct {
  75                         u32 owner_id;
  76                         u16 group_id;
  77                         char filepath[ISFS_MAXPATH];
  78                         u8 ownerperm;
  79                         u8 groupperm;
  80                         u8 otherperm;
  81                         u8 attributes;
  82                         u8 pad0[2];
  83                 } fsattr;
  84                 struct {
  85                         ioctlv vector[4];
  86                         u32 no_entries;
  87                 } fsreaddir;
  88                 struct {
  89                         ioctlv vector[4];
  90                         u32 usage1;
  91                         u8 pad0[28];
  92                         u32 usage2;
  93                 } fsusage;
  94                 struct {
  95                         u32     a;
  96                         u32     b;
  97                         u32     c;
  98                         u32     d;
  99                         u32     e;
 100                         u32     f;
 101                         u32     g;
 102                 } fsstats;
 103         };
 104
 105         isfscallback cb;
 106         void *usrdata;
 107         u32 functype;
 108         void *funcargv[8];
 109 };
 110
 111
 112 static s32 hId = -1;
 113
 114 static s32 _fs_fd = -1;
 115 static u32 _fs_initialized = 0;
 116 static char _dev_fs[] ATTRIBUTE_ALIGN(32) = "/dev/fs";
 117
 118 static s32 __isfsGetStatsCB(s32 result,void *usrdata)
 119 {
 120         struct isfs_cb *param = (struct isfs_cb*)usrdata;
 121         if(result==0) memcpy(param->funcargv[0],&param->fsstats,sizeof(param->fsstats));
 122         return result;
 123 }
 124
 125 static s32 __isfsGetAttrCB(s32 result,void *usrdata)
 126 {
 127         struct isfs_cb *param = (struct isfs_cb*)usrdata;
 128         if(result==0) {
 129                 *(u32*)(param->funcargv[0]) = param->fsattr.owner_id;
 130                 *(u16*)(param->funcargv[1]) = param->fsattr.group_id;
 131                 *(u8*)(param->funcargv[2]) = param->fsattr.attributes;
 132                 *(u8*)(param->funcargv[3]) = param->fsattr.ownerperm;
 133                 *(u8*)(param->funcargv[4]) = param->fsattr.groupperm;
 134                 *(u8*)(param->funcargv[5]) = param->fsattr.otherperm;
 135         }
 136         return result;
 137 }
 138
 139 static s32 __isfsGetUsageCB(s32 result,void *usrdata)
 140 {
 141         struct isfs_cb *param = (struct isfs_cb*)usrdata;
 142         if(result==0) {
 143                 *(u32*)(param->funcargv[0]) = param->fsusage.usage1;
 144                 *(u32*)(param->funcargv[1]) = param->fsusage.usage2;
 145         }
 146         return result;
 147
 148 }
 149 static s32 __isfsReadDirCB(s32 result,void *usrdata)
 150 {
 151         struct isfs_cb *param = (struct isfs_cb*)usrdata;
 152         if(result==0) *(u32*)(param->funcargv[0]) = param->fsreaddir.no_entries;
 153         return result;
 154 }
 155
 156 static s32 __isfsFunctionCB(s32 result,void *usrdata)
 157 {
 158         struct isfs_cb *param = (struct isfs_cb*)usrdata;
 159
 160         if(result>=0) {
 161                 if(param->functype==ISFS_FUNCGETSTAT) __isfsGetStatsCB(result,usrdata);
 162                 else if(param->functype==ISFS_FUNCREADDIR) __isfsReadDirCB(result,usrdata);
 163                 else if(param->functype==ISFS_FUNCGETATTR) __isfsGetAttrCB(result,usrdata);
 164                 else if(param->functype==ISFS_FUNCGETUSAGE) __isfsGetUsageCB(result,usrdata);
 165         }
 166         if(param->cb!=NULL) param->cb(result,param->usrdata);
 167
 168         iosFree(hId,param);
 169         return result;
 170 }
 171
 172 s32 ISFS_Initialize()
 173 {
 174         s32 ret = IPC_OK;
 175
 176         if(_fs_fd<0) {
 177                 _fs_fd = IOS_Open(_dev_fs,0);
 178                 if(_fs_fd<0) return _fs_fd;
 179         }
 180
 181         if(_fs_initialized==0) {
 182                 hId = iosCreateHeap(ISFS_HEAPSIZE);
 183                 if(hId<0) return IPC_ENOMEM;
 184
 185                 _fs_initialized = 1;
 186         }
 187         return ret;
 188 }
 189
 190 s32 ISFS_Deinitialize()
 191 {
 192         if(_fs_fd<0) return ISFS_EINVAL;
 193
 194         IOS_Close(_fs_fd);
 195         _fs_fd = -1;
 196
 197         iosDestroyHeap(hId);
 198         _fs_initialized = 0;
 199
 200         return 0;
 201 }
 202
 203 s32 ISFS_ReadDir(const char *filepath,char *name_list,u32 *num)
 204 {
 205         s32 ret;
 206         s32 len,cnt;
 207         s32 ilen,olen;
 208         struct isfs_cb *param;
 209
 210         if(_fs_fd<0 || filepath==NULL || num==NULL) return ISFS_EINVAL;
 211         if(name_list!=NULL && ((u32)name_list%32)!=0) return ISFS_EINVAL;
 212
 213         len = strnlen(filepath,ISFS_MAXPATH);
 214         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 215
 216         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 217         if(param==NULL) return ISFS_ENOMEM;
 218
 219         memcpy(param->filepath,filepath,(len+1));
 220
 221         param->fsreaddir.vector[0].data = param->filepath;
 222         param->fsreaddir.vector[0].len = ISFS_MAXPATH;
 223         param->fsreaddir.vector[1].data = &param->fsreaddir.no_entries;
 224         param->fsreaddir.vector[1].len = sizeof(u32);
 225
 226         if(name_list!=NULL) {
 227                 ilen = olen = 2;
 228                 cnt = *num;
 229                 param->fsreaddir.no_entries = cnt;
 230                 param->fsreaddir.vector[2].data = name_list;
 231                 param->fsreaddir.vector[2].len = (cnt*13);
 232                 param->fsreaddir.vector[3].data = &param->fsreaddir.no_entries;
 233                 param->fsreaddir.vector[3].len = sizeof(u32);
 234         } else
 235                 ilen = olen = 1;
 236
 237         ret = IOS_Ioctlv(_fs_fd,ISFS_IOCTL_READDIR,ilen,olen,param->fsreaddir.vector);
 238         if(ret==0) *num = param->fsreaddir.no_entries;
 239
 240         if(param!=NULL) iosFree(hId,param);
 241         return ret;
 242 }
 243
 244 s32 ISFS_ReadDirAsync(const char *filepath,char *name_list,u32 *num,isfscallback cb,void *usrdata)
 245 {
 246         s32 len,cnt;
 247         s32 ilen,olen;
 248         struct isfs_cb *param;
 249
 250         if(_fs_fd<0 || filepath==NULL || num==NULL) return ISFS_EINVAL;
 251         if(name_list!=NULL && ((u32)name_list%32)!=0) return ISFS_EINVAL;
 252
 253         len = strnlen(filepath,ISFS_MAXPATH);
 254         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 255
 256         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 257         if(param==NULL) return ISFS_ENOMEM;
 258
 259         param->cb = cb;
 260         param->usrdata = usrdata;
 261         param->funcargv[0] = num;
 262         param->functype = ISFS_FUNCREADDIR;
 263         memcpy(param->filepath,filepath,(len+1));
 264
 265         param->fsreaddir.vector[0].data = param->filepath;
 266         param->fsreaddir.vector[0].len = ISFS_MAXPATH;
 267         param->fsreaddir.vector[1].data = &param->fsreaddir.no_entries;
 268         param->fsreaddir.vector[1].len = sizeof(u32);
 269
 270         if(name_list!=NULL) {
 271                 ilen = olen = 2;
 272                 cnt = *num;
 273                 param->fsreaddir.no_entries = cnt;
 274                 param->fsreaddir.vector[2].data = name_list;
 275                 param->fsreaddir.vector[2].len = (cnt*13);
 276                 param->fsreaddir.vector[3].data = &param->fsreaddir.no_entries;
 277                 param->fsreaddir.vector[3].len = sizeof(u32);
 278         } else
 279                 ilen = olen = 1;
 280
 281         return IOS_IoctlvAsync(_fs_fd,ISFS_IOCTL_READDIR,ilen,olen,param->fsreaddir.vector,__isfsFunctionCB,param);
 282 }
 283
 284 s32 ISFS_CreateDir(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)
 285 {
 286         s32 ret;
 287         s32 len;
 288         struct isfs_cb *param;
 289
 290         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 291
 292         len = strnlen(filepath,ISFS_MAXPATH);
 293         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 294
 295         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 296         if(param==NULL) return ISFS_ENOMEM;
 297
 298         memcpy(param->fsattr.filepath ,filepath,(len+1));
 299
 300         param->fsattr.attributes = attributes;
 301         param->fsattr.ownerperm = owner_perm;
 302         param->fsattr.groupperm = group_perm;
 303         param->fsattr.otherperm = other_perm;
 304         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_CREATEDIR,&param->fsattr,sizeof(param->fsattr),NULL,0);
 305
 306         if(param!=NULL) iosFree(hId,param);
 307         return ret;
 308 }
 309
 310 s32 ISFS_CreateDirAsync(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void *usrdata)
 311 {
 312         s32 len;
 313         struct isfs_cb *param;
 314
 315         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 316
 317         len = strnlen(filepath,ISFS_MAXPATH);
 318         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 319
 320         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 321         if(param==NULL) return ISFS_ENOMEM;
 322
 323         param->cb = cb;
 324         param->usrdata = usrdata;
 325         param->functype = ISFS_FUNCNULL;
 326         memcpy(param->fsattr.filepath,filepath,(len+1));
 327
 328         param->fsattr.attributes = attributes;
 329         param->fsattr.ownerperm = owner_perm;
 330         param->fsattr.groupperm = group_perm;
 331         param->fsattr.otherperm = other_perm;
 332         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_CREATEDIR,&param->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
 333 }
 334
 335 s32 ISFS_Open(const char *filepath,u8 mode)
 336 {
 337         s32 ret;
 338         s32 len;
 339         struct isfs_cb *param;
 340
 341         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 342
 343         len = strnlen(filepath,ISFS_MAXPATH);
 344         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 345
 346         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 347         if(param==NULL) return ISFS_ENOMEM;
 348
 349         memcpy(param->filepath,filepath,(len+1));
 350         ret = IOS_Open(param->filepath,mode);
 351
 352         if(param!=NULL) iosFree(hId,param);
 353         return ret;
 354 }
 355
 356 s32 ISFS_OpenAsync(const char *filepath,u8 mode,isfscallback cb,void *usrdata)
 357 {
 358         s32 len;
 359         struct isfs_cb *param;
 360
 361         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 362
 363         len = strnlen(filepath,ISFS_MAXPATH);
 364         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 365
 366         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 367         if(param==NULL) return ISFS_ENOMEM;
 368
 369         param->cb = cb;
 370         param->usrdata = usrdata;
 371         param->functype = ISFS_FUNCNULL;
 372         memcpy(param->filepath,filepath,(len+1));
 373         return IOS_OpenAsync(param->filepath,mode,__isfsFunctionCB,param);
 374 }
 375
 376 s32 ISFS_Format()
 377 {
 378         if(_fs_fd<0) return ISFS_EINVAL;
 379
 380         return IOS_Ioctl(_fs_fd,ISFS_IOCTL_FORMAT,NULL,0,NULL,0);
 381 }
 382
 383 s32 ISFS_FormatAsync(isfscallback cb,void *usrdata)
 384 {
 385         struct isfs_cb *param;
 386
 387         if(_fs_fd<0) return ISFS_EINVAL;
 388
 389         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 390         if(param==NULL) return ISFS_ENOMEM;
 391
 392         param->cb = cb;
 393         param->usrdata = usrdata;
 394         param->functype = ISFS_FUNCNULL;
 395         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_FORMAT,NULL,0,NULL,0,__isfsFunctionCB,param);
 396 }
 397
 398 s32 ISFS_GetStats(void *stats)
 399 {
 400         s32 ret = ISFS_OK;
 401         struct isfs_cb *param;
 402
 403         if(_fs_fd<0 || stats==NULL) return ISFS_EINVAL;
 404
 405         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 406         if(param==NULL) return ISFS_ENOMEM;
 407
 408         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_GETSTATS,NULL,0,&param->fsstats,sizeof(param->fsstats));
 409         if(ret==IPC_OK) memcpy(stats,&param->fsstats,sizeof(param->fsstats));
 410
 411         if(param!=NULL) iosFree(hId,param);
 412         return ret;
 413 }
 414
 415 s32 ISFS_GetStatsAsync(void *stats,isfscallback cb,void *usrdata)
 416 {
 417         struct isfs_cb *param;
 418
 419         if(_fs_fd<0 || stats==NULL) return ISFS_EINVAL;
 420
 421         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 422         if(param==NULL) return ISFS_ENOMEM;
 423
 424         param->cb = cb;
 425         param->usrdata = usrdata;
 426         param->functype = ISFS_FUNCGETSTAT;
 427         param->funcargv[0] = stats;
 428         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_GETSTATS,NULL,0,&param->fsstats,sizeof(param->fsstats),__isfsFunctionCB,param);
 429 }
 430
 431 s32 ISFS_Write(s32 fd,const void *buffer,u32 length)
 432 {
 433         if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
 434
 435         return IOS_Write(fd,buffer,length);
 436 }
 437
 438 s32 ISFS_WriteAsync(s32 fd,const void *buffer,u32 length,isfscallback cb,void *usrdata)
 439 {
 440         struct isfs_cb *param;
 441
 442         if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
 443
 444         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 445         if(param==NULL) return ISFS_ENOMEM;
 446
 447         param->cb = cb;
 448         param->usrdata = usrdata;
 449         param->functype = ISFS_FUNCNULL;
 450         return IOS_WriteAsync(fd,buffer,length,__isfsFunctionCB,param);
 451 }
 452
 453 s32 ISFS_Read(s32 fd,void *buffer,u32 length)
 454 {
 455         if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
 456
 457         return IOS_Read(fd,buffer,length);
 458 }
 459
 460 s32 ISFS_ReadAsync(s32 fd,void *buffer,u32 length,isfscallback cb,void *usrdata)
 461 {
 462         struct isfs_cb *param;
 463
 464         if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
 465
 466         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 467         if(param==NULL) return ISFS_ENOMEM;
 468
 469         param->cb = cb;
 470         param->usrdata = usrdata;
 471         param->functype = ISFS_FUNCNULL;
 472         return IOS_ReadAsync(fd,buffer,length,__isfsFunctionCB,param);
 473 }
 474
 475 s32 ISFS_Seek(s32 fd,s32 where,s32 whence)
 476 {
 477         return IOS_Seek(fd,where,whence);
 478 }
 479
 480 s32 ISFS_SeekAsync(s32 fd,s32 where,s32 whence,isfscallback cb,void *usrdata)
 481 {
 482         struct isfs_cb *param;
 483
 484         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 485         if(param==NULL) return ISFS_ENOMEM;
 486
 487         param->cb = cb;
 488         param->usrdata = usrdata;
 489         param->functype = ISFS_FUNCNULL;
 490         return IOS_SeekAsync(fd,where,whence,__isfsFunctionCB,param);
 491 }
 492
 493 s32 ISFS_CreateFile(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)
 494 {
 495         s32 ret;
 496         s32 len;
 497         struct isfs_cb *param;
 498
 499         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 500
 501         len = strnlen(filepath,ISFS_MAXPATH);
 502         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 503
 504         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 505         if(param==NULL) return ISFS_ENOMEM;
 506
 507         memcpy(param->fsattr.filepath,filepath,(len+1));
 508
 509         param->fsattr.attributes = attributes;
 510         param->fsattr.ownerperm = owner_perm;
 511         param->fsattr.groupperm = group_perm;
 512         param->fsattr.otherperm = other_perm;
 513         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_CREATEFILE,&param->fsattr,sizeof(param->fsattr),NULL,0);
 514
 515         if(param!=NULL) iosFree(hId,param);
 516         return ret;
 517 }
 518
 519 s32 ISFS_CreateFileAsync(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void *usrdata)
 520 {
 521         s32 len;
 522         struct isfs_cb *param;
 523
 524         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 525
 526         len = strnlen(filepath,ISFS_MAXPATH);
 527         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 528
 529         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 530         if(param==NULL) return ISFS_ENOMEM;
 531
 532         param->cb = cb;
 533         param->usrdata = usrdata;
 534         param->functype = ISFS_FUNCNULL;
 535         memcpy(param->fsattr.filepath,filepath,(len+1));
 536
 537         param->fsattr.attributes = attributes;
 538         param->fsattr.ownerperm = owner_perm;
 539         param->fsattr.groupperm = group_perm;
 540         param->fsattr.otherperm = other_perm;
 541         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_CREATEFILE,&param->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
 542 }
 543
 544 s32 ISFS_Delete(const char *filepath)
 545 {
 546         s32 ret;
 547         s32 len;
 548         struct isfs_cb *param;
 549
 550         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 551
 552         len = strnlen(filepath,ISFS_MAXPATH);
 553         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 554
 555         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 556         if(param==NULL) return ISFS_ENOMEM;
 557
 558         memcpy(param->filepath,filepath,(len+1));
 559         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_DELETE,param->filepath,ISFS_MAXPATH,NULL,0);
 560
 561         if(param!=NULL) iosFree(hId,param);
 562         return ret;
 563 }
 564
 565 s32 ISFS_DeleteAsync(const char *filepath,isfscallback cb,void *usrdata)
 566 {
 567         s32 len;
 568         struct isfs_cb *param;
 569
 570         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 571
 572         len = strnlen(filepath,ISFS_MAXPATH);
 573         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 574
 575         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 576         if(param==NULL) return ISFS_ENOMEM;
 577
 578         param->cb = cb;
 579         param->usrdata = usrdata;
 580         param->functype = ISFS_FUNCNULL;
 581         memcpy(param->filepath,filepath,(len+1));
 582         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_DELETE,param->filepath,ISFS_MAXPATH,NULL,0,__isfsFunctionCB,param);
 583 }
 584
 585 s32 ISFS_Close(s32 fd)
 586 {
 587         if(fd<0) return 0;
 588
 589         return IOS_Close(fd);
 590 }
 591
 592 s32 ISFS_CloseAsync(s32 fd,isfscallback cb,void *usrdata)
 593 {
 594         struct isfs_cb *param;
 595
 596         if(fd<0) return 0;
 597
 598         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 599         if(param==NULL) return ISFS_ENOMEM;
 600
 601         param->cb = cb;
 602         param->usrdata = usrdata;
 603         param->functype = ISFS_FUNCNULL;
 604         return IOS_CloseAsync(fd,__isfsFunctionCB,param);
 605 }
 606
 607 s32 ISFS_GetFileStats(s32 fd,fstats *status)
 608 {
 609         if(status==NULL || ((u32)status%32)!=0) return ISFS_EINVAL;
 610
 611         return IOS_Ioctl(fd,ISFS_IOCTL_GETFILESTATS,NULL,0,status,sizeof(fstats));
 612 }
 613
 614 s32 ISFS_GetFileStatsAsync(s32 fd,fstats *status,isfscallback cb,void *usrdata)
 615 {
 616         struct isfs_cb *param;
 617
 618         if(status==NULL || ((u32)status%32)!=0) return ISFS_EINVAL;
 619
 620         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 621         if(param==NULL) return ISFS_ENOMEM;
 622
 623         param->cb = cb;
 624         param->usrdata = usrdata;
 625         param->functype = ISFS_FUNCNULL;
 626         return IOS_IoctlAsync(fd,ISFS_IOCTL_GETFILESTATS,NULL,0,status,sizeof(fstats),__isfsFunctionCB,param);
 627 }
 628
 629 s32 ISFS_GetAttr(const char *filepath,u32 *ownerID,u16 *groupID,u8 *attributes,u8 *ownerperm,u8 *groupperm,u8 *otherperm)
 630 {
 631         s32 ret;
 632         s32 len;
 633         struct isfs_cb *param;
 634
 635         if(_fs_fd<0 || filepath==NULL || ownerID==NULL || groupID==NULL
 636                 || attributes==NULL || ownerperm==NULL || groupperm==NULL || otherperm==NULL) return ISFS_EINVAL;
 637
 638         len = strnlen(filepath,ISFS_MAXPATH);
 639         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 640
 641         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 642         if(param==NULL) return ISFS_ENOMEM;
 643
 644         memcpy(param->filepath,filepath,(len+1));
 645         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_GETATTR,param->filepath,ISFS_MAXPATH,&param->fsattr,sizeof(param->fsattr));
 646         if(ret==IPC_OK) {
 647                 *ownerID = param->fsattr.owner_id;
 648                 *groupID = param->fsattr.group_id;
 649                 *ownerperm = param->fsattr.ownerperm;
 650                 *groupperm = param->fsattr.groupperm;
 651                 *otherperm = param->fsattr.otherperm;
 652                 *attributes = param->fsattr.attributes;
 653         }
 654
 655         if(param!=NULL) iosFree(hId,param);
 656         return ret;
 657 }
 658
 659 s32 ISFS_GetAttrAsync(const char *filepath,u32 *ownerID,u16 *groupID,u8 *attributes,u8 *ownerperm,u8 *groupperm,u8 *otherperm,isfscallback cb,void *usrdata)
 660 {
 661         s32 len;
 662         struct isfs_cb *param;
 663
 664         if(_fs_fd<0 || filepath==NULL || ownerID==NULL || groupID==NULL
 665                 || attributes==NULL || ownerperm==NULL || groupperm==NULL || otherperm==NULL) return ISFS_EINVAL;
 666
 667         len = strnlen(filepath,ISFS_MAXPATH);
 668         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 669
 670         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 671         if(param==NULL) return ISFS_ENOMEM;
 672
 673         param->cb = cb;
 674         param->usrdata = usrdata;
 675         param->functype = ISFS_FUNCGETATTR;
 676         param->funcargv[0] = ownerID;
 677         param->funcargv[1] = groupID;
 678         param->funcargv[2] = attributes;
 679         param->funcargv[3] = ownerperm;
 680         param->funcargv[4] = groupperm;
 681         param->funcargv[5] = otherperm;
 682         memcpy(param->filepath,filepath,(len+1));
 683         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_GETATTR,param->filepath,ISFS_MAXPATH,&param->fsattr,sizeof(param->fsattr),__isfsFunctionCB,param);
 684 }
 685
 686 s32 ISFS_Rename(const char *filepathOld,const char *filepathNew)
 687 {
 688         s32 ret;
 689         s32 len0,len1;
 690         struct isfs_cb *param;
 691
 692         if(_fs_fd<0 || filepathOld==NULL || filepathNew==NULL) return ISFS_EINVAL;
 693
 694         len0 = strnlen(filepathOld,ISFS_MAXPATH);
 695         if(len0>=ISFS_MAXPATH) return ISFS_EINVAL;
 696
 697         len1 = strnlen(filepathNew,ISFS_MAXPATH);
 698         if(len1>=ISFS_MAXPATH) return ISFS_EINVAL;
 699
 700         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 701         if(param==NULL) return ISFS_ENOMEM;
 702
 703         memcpy(param->fsrename.filepathOld,filepathOld,(len0+1));
 704         memcpy(param->fsrename.filepathNew,filepathNew,(len1+1));
 705         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_RENAME,&param->fsrename,sizeof(param->fsrename),NULL,0);
 706
 707         if(param!=NULL) iosFree(hId,param);
 708         return ret;
 709 }
 710
 711 s32 ISFS_RenameAsync(const char *filepathOld,const char *filepathNew,isfscallback cb,void *usrdata)
 712 {
 713         s32 len0,len1;
 714         struct isfs_cb *param;
 715
 716         if(_fs_fd<0 || filepathOld==NULL || filepathNew==NULL) return ISFS_EINVAL;
 717
 718         len0 = strnlen(filepathOld,ISFS_MAXPATH);
 719         if(len0>=ISFS_MAXPATH) return ISFS_EINVAL;
 720
 721         len1 = strnlen(filepathNew,ISFS_MAXPATH);
 722         if(len1>=ISFS_MAXPATH) return ISFS_EINVAL;
 723
 724         param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
 725         if(param==NULL) return ISFS_ENOMEM;
 726
 727         param->cb = cb;
 728         param->usrdata = usrdata;
 729         param->functype = ISFS_FUNCNULL;
 730         memcpy(param->fsrename.filepathOld,filepathOld,(len0+1));
 731         memcpy(param->fsrename.filepathNew,filepathNew,(len1+1));
 732         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_RENAME,&param->fsrename,sizeof(param->fsrename),NULL,0,__isfsFunctionCB,param);
 733 }
 734
 735 s32 ISFS_SetAttr(const char *filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm)
 736 {
 737         s32 ret, len;
 738         struct isfs_cb *param;
 739
 740         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 741
 742         len = strnlen(filepath, ISFS_MAXPATH);
 743         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 744
 745         param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
 746         if(param==NULL) return ISFS_ENOMEM;
 747
 748         memcpy(param->fsattr.filepath, filepath, (len+1));
 749         param->fsattr.owner_id = ownerID;
 750         param->fsattr.group_id = groupID;
 751         param->fsattr.ownerperm = ownerperm;
 752         param->fsattr.groupperm = groupperm;
 753         param->fsattr.otherperm = otherperm;
 754         param->fsattr.attributes = attributes;
 755
 756         ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_SETATTR,&param->fsattr,sizeof(param->fsattr),NULL,0);
 757
 758         if(param!=NULL) iosFree(hId,param);
 759         return ret;
 760 }
 761
 762 s32 ISFS_SetAttrAsync(const char *filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm,isfscallback cb,void *usrdata)
 763 {
 764         s32 len;
 765         struct isfs_cb *param;
 766
 767         if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
 768
 769         len = strnlen(filepath, ISFS_MAXPATH);
 770         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 771
 772         param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
 773         if(param==NULL) return ISFS_ENOMEM;
 774
 775         param->cb = cb;
 776         param->usrdata = usrdata;
 777         param->functype = ISFS_FUNCNULL;
 778         memcpy(param->fsattr.filepath, filepath, (len+1));
 779         param->fsattr.owner_id = ownerID;
 780         param->fsattr.group_id = groupID;
 781         param->fsattr.ownerperm = ownerperm;
 782         param->fsattr.groupperm = groupperm;
 783         param->fsattr.otherperm = otherperm;
 784         param->fsattr.attributes = attributes;
 785         return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_SETATTR,&param->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
 786 }
 787
 788 s32 ISFS_GetUsage(const char* filepath, u32* usage1, u32* usage2)
 789 {
 790         s32 ret,len;
 791         struct isfs_cb *param;
 792
 793         if(_fs_fd<0 || filepath==NULL || usage1==NULL || usage2 == NULL)
 794                 return ISFS_EINVAL;
 795
 796         len = strnlen(filepath, ISFS_MAXPATH);
 797         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 798
 799         param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
 800         if(param==NULL) return ISFS_ENOMEM;
 801
 802         memcpy(param->filepath,filepath,(len+1));
 803
 804         param->fsusage.vector[0].data = param->filepath;
 805         param->fsusage.vector[0].len = ISFS_MAXPATH;
 806         param->fsusage.vector[1].data = &param->fsusage.usage1;
 807         param->fsusage.vector[1].len = sizeof(u32);
 808         param->fsusage.vector[2].data = &param->fsusage.usage2;
 809         param->fsusage.vector[2].len = sizeof(u32);
 810         ret = IOS_Ioctlv(_fs_fd,ISFS_IOCTL_GETUSAGE,1,2,param->fsusage.vector);
 811         if(ret==IPC_OK) {
 812                 *usage1 = param->fsusage.usage1;
 813                 *usage2 = param->fsusage.usage2;
 814         }
 815
 816         if(param!=NULL) iosFree(hId, param);
 817         return ret;
 818 }
 819
 820 s32 ISFS_GetUsageAsync(const char* filepath, u32* usage1, u32* usage2,isfscallback cb,void *usrdata)
 821 {
 822         s32 len;
 823         struct isfs_cb *param;
 824
 825         if(_fs_fd<0 || filepath==NULL || usage1==NULL || usage2 == NULL)
 826                 return ISFS_EINVAL;
 827
 828         len = strnlen(filepath, ISFS_MAXPATH);
 829         if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
 830
 831         param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
 832         if(param==NULL) return ISFS_ENOMEM;
 833
 834         param->cb = cb;
 835         param->usrdata = usrdata;
 836         param->functype = ISFS_FUNCGETUSAGE;
 837         param->funcargv[0] = usage1;
 838         param->funcargv[1] = usage2;
 839         memcpy(param->filepath,filepath,(len+1));
 840
 841         param->fsusage.vector[0].data = param->filepath;
 842         param->fsusage.vector[0].len = ISFS_MAXPATH;
 843         param->fsusage.vector[1].data = &param->fsusage.usage1;
 844         param->fsusage.vector[1].len = sizeof(u32);
 845         param->fsusage.vector[2].data = &param->fsusage.usage2;
 846         param->fsusage.vector[2].len = sizeof(u32);
 847         return IOS_IoctlvAsync(_fs_fd,ISFS_IOCTL_GETUSAGE,1,2,param->fsusage.vector,__isfsFunctionCB,param);
 848 }
 849
 850
 851 #endif /* defined(HW_RVL) */