ffs_coat.c

是一个手机功能的模拟程序

T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_NOTFOUND);
  _PAR_CHECK_NULL (stat, 2, EFFS_NOTFOUND);

  /* ffs_linkstat is deprecated, use ffs_lstat instead */
  ffs_ret = ffs_lstat (name, stat);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_remove(const char *name,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_remove"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_NOTFOUND);

  ffs_ret = ffs_remove (name);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_mkdir(const char *name,
                    T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_mkdir"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);

  ffs_ret = ffs_mkdir (name);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_symlink(const char *name, const char *actualpath,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_symlink"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (actualpath, 2, EFFS_BADNAME);

  ffs_ret = ffs_symlink (name, actualpath);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_rename(const char *oldname, const char *newname,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_rename"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (oldname, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (newname, 2, EFFS_BADNAME);

  ffs_ret = ffs_rename (oldname, newname);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_file_write(const char *name, void *addr, T_FFS_SIZE size,
                      T_FFS_OPEN_FLAGS flags,
                      T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_file_write"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (addr, 2, EFFS_NOTAFILE);
  _PAR_CHECK_LESSZERO (size, 2, EFFS_FILETOOBIG);

  ffs_ret = ffs_file_write (name, addr, size, flags);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_fcreate(const char *name, void *addr, T_FFS_SIZE size,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_fcreate"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (addr, 2, EFFS_NOTAFILE);
  _PAR_CHECK_LESSZERO (size, 2, EFFS_FILETOOBIG);

  /* ffs_fcreate is deprecated, use ffs_file_write instead */
  ffs_ret = ffs_file_write (name, addr, size, FFS_O_CREATE|FFS_O_EXCL);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_fupdate(const char *name, void *addr, T_FFS_SIZE size,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_fupdate"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (addr, 2, EFFS_NOTAFILE);
  _PAR_CHECK_LESSZERO (size, 2, EFFS_FILETOOBIG);

  /* ffs_fupdate is deprecated, use ffs_file_write instead */
  ffs_ret = ffs_file_write (name, addr, size, FFS_O_TRUNC);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_fwrite(const char *name, void *addr, T_FFS_SIZE size,
                    T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_fwrite"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (name, 1, EFFS_BADNAME);
  _PAR_CHECK_NULL (addr, 2, EFFS_NOTAFILE);
  _PAR_CHECK_LESSZERO (size, 2, EFFS_FILETOOBIG);

  /* ffs_fwrite is deprecated, use ffs_file_write instead */
  ffs_ret = ffs_file_write (name, addr, size, FFS_O_CREATE|FFS_O_TRUNC);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_fcontrol(const char *pathname, INT8 action, int param,
                     T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_fcontrol"
T_FFS_SIZE  ffs_ret;

  _STATE_CHECK (ffs_ret);
  _PAR_CHECK_NULL (pathname, 1, EFFS_BADNAME);

  ffs_ret = ffs_fcontrol (pathname, action, param);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}


T_FFS_RET _FFS_query(INT8 query, void *p,
                   T_HANDLE hMMI, const char * const file, int line)
{
#define   _FFS_FCT_NAME "ffs_query"
T_FFS_SIZE  ffs_ret;

  _PAR_CHECK_NULL (p, 2, EFFS_BADNAME);

  ffs_ret = ffs_query (query, p);
  _ERROR_CHECK (ffs_ret);

  return ffs_ret;
#undef   _FFS_FCT_NAME
}

#if defined(FFS_PAR_CHECK)
static  void _FFS_ParCheck (const char * const  errmsg, const char * const  fct,
                          int parameter,
                          T_HANDLE hMMI, const char * const file, int line)
{
  char *f;
  int   l;
  PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
  trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

  l = strlen (file);
  if (l <= 20)
    f = (char *)file;
  else
    f = (char *)file + l - 20;

  sprintf (trc_ind->trc_buf, "FFS PAR ERR:par %u of %s is %s (%s#%u)",
    parameter, fct?fct:"", errmsg?errmsg:"", f, line);
  trc_ind->trc_len = strlen (trc_ind->trc_buf);

  PSEND (hMMI, trc_ind);
}
#endif  /* FFS_PAR_CHECK */

char *ffs_strerror(effs_t error)
{
    switch (error) {
    case EFFS_OK: return "ok"; /* 0 */
    case EFFS_NODEVICE: return "flash device unknown"; /* -1 */
    case EFFS_CORRUPTED: return "filesystem corrupted!?"; /* -2 */
    case EFFS_NOPREFORMAT: return "ffs not preformatted"; /* -3 */
    case EFFS_NOFORMAT: return "ffs not formatted"; /* -4 */
    case EFFS_BADFORMAT: return "incompatible ffs version"; /* -5 */
    case EFFS_MAGIC: return "bad magic"; /* -6 */
    case EFFS_AGAIN: return "not ready, try again later"; /* -7 */
    case EFFS_NOSYS: return "function not implemented"; /* -8 */
    case EFFS_DRIVER: return "ffs device driver error"; /* -9 */
    case EFFS_NOSPACE: return "out of data space"; /* -10 */
    case EFFS_FSFULL: return "file system full, no free inodes"; /* -11 */
    case EFFS_BADNAME: return "bad filename"; /* -12 */
    case EFFS_NOTFOUND: return "object not found"; /* -13 */
    case EFFS_EXISTS: return "object exists"; /* -14 */
    case EFFS_ACCESS: return "access permission violation"; /* -15 */
    case EFFS_NAMETOOLONG: return "filename too long"; /* -16 */
    case EFFS_INVALID: return "invalid argument"; /* -17 */
    case EFFS_DIRNOTEMPTY: return "directory not empty"; /* -18 */
    case EFFS_NOTADIR: return "object is not a directory"; /* -19 */
    case EFFS_SPARE: return "SPARE"; /* -20 */
    case EFFS_FILETOOBIG: return "file too big"; /* -21 */
    case EFFS_NOTAFILE: return "object is not a file"; /* -22 */
    case EFFS_PATHTOODEEP: return "path too deep"; /* -23 */
    case EFFS_NUMFD: return "Max number of open files reached"; /* -24 */
    case EFFS_BADFD: return "Bad file descriptor"; /* -25 */
    case EFFS_BADOP: return "Bad operation"; /* -26 */
    case EFFS_LOCKED: return "The file is locked"; /* -27 */
    case EFFS_TOOBIG: return "too big (tmffs buffer overflow)"; /* -30 */
    case EFFS_MEMORY: return "out of memory"; /* -31 */
    case EFFS_MSGSEND: return "message send failed"; /* -32 */
    case EFFS_SIBLINGLOOP: return "directory sibling loop"; /* -40 */
    case EFFS_NOBLOCKS: return "No more blocks!?"; /* -41 */
    default: return "unknown ffs error code!";
    }
}

static  void _FFS_ErrorMsg (const char * const  errmsg, const char * const  fct,
                          int ffs_ret,
                          T_HANDLE hMMI, const char * const file, int line)
{
  char *f;
  int   l;
  PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
  trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

  l = strlen (file);
  if (l <= 20)
    f = (char *)file;
  else
    f = (char *)file + l - 20;

  sprintf (trc_ind->trc_buf, "FFS ERR on %s: %d %s (%s#%u)",
    fct?fct:"", ffs_ret, ffs_strerror (ffs_ret), f, line);
  trc_ind->trc_len = strlen (trc_ind->trc_buf);

  PSEND (hMMI, trc_ind);
}

#endif  /* FFS_COAT_ENABLED */

#if 1
GLOBAL  T_FFS_RET _FFS_StateCheck (const char * const fct,
                                T_HANDLE hMMI, const char * const file, int line)
{
  int query_result;
  int bytes_free, bytes_used, bytes_max, bytes_lost;
  T_FFS_RET ffs_ret;

  SYST_TRACE ("_FFS_StateCheck()");

  bytes_free = bytes_used = bytes_max = bytes_lost = 0;

  ffs_ret = ffs_query (Q_BYTES_FREE, &query_result);
  if (ffs_ret EQ EFFS_OK)
  {
    bytes_free = query_result;
    ffs_ret = ffs_query (Q_BYTES_USED, &query_result);
    if (ffs_ret EQ EFFS_OK)
    {
      bytes_used = query_result;
      ffs_ret = ffs_query (Q_BYTES_LOST, &query_result);
      if (ffs_ret EQ EFFS_OK)
      {
        bytes_lost = query_result;
        ffs_ret = ffs_query (Q_BYTES_MAX, &query_result);
        if (ffs_ret EQ EFFS_OK)
        {
          bytes_max = query_result;
        }
      }
    }
  }

  #if 0
    {
      char *f;
      int   l;

      PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
      trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

      l = strlen (file);
      if (l <= 20)
        f = (char *)file;
      else
        f = (char *)file + l - 20;

      sprintf (trc_ind->trc_buf, "STATE before %s (%s#%u)", fct?fct:"", f, line);
      trc_ind->trc_len = strlen (trc_ind->trc_buf);

      PSEND (hMMI, trc_ind);
    }
  #endif  /* 0|1 */
  {
    PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
    trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

    sprintf (trc_ind->trc_buf, "FFS free=%5u used=%5u lost=%5u max=%6u",
      bytes_free, bytes_used, bytes_lost, bytes_max);
    trc_ind->trc_len = strlen (trc_ind->trc_buf);

    SYST_TRACE ((char *)trc_ind->trc_buf);

    PSEND (hMMI, trc_ind);
  }

  return EFFS_OK;
}
#else /* 1|0 */
GLOBAL  T_FFS_RET _FFS_StateCheck (const char * const fct,
                                T_HANDLE hMMI, const char * const file, int line)
{
  USHORT query_result;
  int objects_free, objects_used, objects_max, objects_lost;
  T_FFS_RET ffs_ret;

  SYST_TRACE ("_FFS_StateCheck()");

  ffs_ret = ffs_query (Q_OBJECTS_FREE, &query_result);
  if (ffs_ret NEQ EFFS_OK)
    return ffs_ret;
  else
    objects_free = query_result;

  ffs_ret = ffs_query (Q_INODES_USED, &query_result);
  if (ffs_ret NEQ EFFS_OK)
    return ffs_ret;
  else
    objects_used = query_result;

  ffs_ret = ffs_query (Q_INODES_LOST, &query_result);
  if (ffs_ret NEQ EFFS_OK)
    return ffs_ret;
  else
    objects_lost = query_result;

  ffs_ret = ffs_query (Q_OBJECTS_MAX, &query_result);
  if (ffs_ret NEQ EFFS_OK)
    return ffs_ret;
  else
    objects_max = query_result;

  #if 0
    {
      char *f;
      int   l;

      PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
      trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

      l = strlen (file);
      if (l <= 20)
        f = (char *)file;
      else
        f = (char *)file + l - 20;

      sprintf (trc_ind->trc_buf, "STATE before %s (%s#%u)", fct?fct:"", f, line);
      trc_ind->trc_len = strlen (trc_ind->trc_buf);

      PSEND (hMMI, trc_ind);
    }
  #endif  /* 0|1 */
  {
    PALLOC (trc_ind, ACI_TRC_IND); /* T_ACI_TRC_IND */
    trc_ind->cmd_src = 1; /* CMD_SRC_ATI_1 */

    sprintf (trc_ind->trc_buf, "FFS objs: free=%3u used=%3u lost=%3u max=%3u",
      objects_free, objects_used, objects_lost, objects_max);
    trc_ind->trc_len = strlen (trc_ind->trc_buf);

    SYST_TRACE ((char *)trc_ind->trc_buf);

    PSEND (hMMI, trc_ind);
  }

  return EFFS_OK;
}
#endif /* 1|0 */

#endif