xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor

This commit is contained in:
Hongze Cheng 2020-11-24 07:11:57 +00:00
parent f68b434356
commit eecfc4976f
5 changed files with 166 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/inc/tfs.h
View File

@ -29,14 +29,21 @@ typedef struct {
#define TFS_UNDECIDED_LEVEL -1 #define TFS_UNDECIDED_LEVEL -1
#define TFS_UNDECIDED_ID -1 #define TFS_UNDECIDED_ID -1
#define TFS_PRIMARY_LEVEL 0
#define TFS_PRIMARY_ID 0
// tfs.c ==================================== // FS APIs ====================================
int tfsInit(SDiskCfg *pDiskCfg, int ndisk); int tfsInit(SDiskCfg *pDiskCfg, int ndisk);
void tfsDestroy(); void tfsDestroy();
int tfsUpdateInfo(); void tfsUpdateInfo();
const char *tfsGetDiskName(int level, int id); const char *TFS_PRIMARY_PATH();
const char *tfsPrimaryPath(); const char *TFS_DISK_PATH(int level, int id);
// MANIP APIS ====================================
int tfsMkdir(const char *rname);
int tfsRmdir(const char *rname);
int tfsRename(char *orname, char *nrname);
// tfcntl.c ==================================== // tfcntl.c ====================================
typedef struct TFSFILE { typedef struct TFSFILE {

60
src/tfs/inc/tfsint.h
View File

@ -33,40 +33,56 @@ extern int fsDebugFlag;
#define fDebug(...) { if (fsDebugFlag & DEBUG_DEBUG) { taosPrintLog("TFS ", cqDebugFlag, __VA_ARGS__); }} #define fDebug(...) { if (fsDebugFlag & DEBUG_DEBUG) { taosPrintLog("TFS ", cqDebugFlag, __VA_ARGS__); }}
#define fTrace(...) { if (fsDebugFlag & DEBUG_TRACE) { taosPrintLog("TFS ", cqDebugFlag, __VA_ARGS__); }} #define fTrace(...) { if (fsDebugFlag & DEBUG_TRACE) { taosPrintLog("TFS ", cqDebugFlag, __VA_ARGS__); }}
// tdisk.c // tdisk.c ======================================================
typedef struct SDisk SDisk; typedef struct {
int32_t nfiles;
int64_t size;
int64_t free;
} SDiskMeta;
SDisk *tfsNewDisk(int level, int id, char *dir); typedef struct SDisk {
void tfsFreeDisk(SDisk *pDisk); int level;
int tfsUpdateDiskInfo(SDisk *pDisk); int id;
char dir[TSDB_FILENAME_LEN];
SDiskMeta dmeta;
} SDisk;
const char *tfsDiskDir(SDisk *pDisk); #define DISK_LEVEL(pd) ((pd)->level)
#define DISK_ID(pd) ((pd)->id)
#define DISK_DIR(pd) ((pd)->dir)
#define DISK_META(pd) ((pd)->dmeta)
#define DISK_SIZE(pd) ((pd)->dmeta.size)
#define DISK_FREE_SIZE(pd) ((pd)->dmeta.free)
#define DISK_NFILES(pd) ((pd)->dmeta.nfiles)
// ttier.c SDisk *tfsNewDisk(int level, int id, const char *dir);
SDisk *tfsFreeDisk(SDisk *pDisk);
void tfsUpdateDiskInfo(SDisk *pDisk);
// ttier.c ======================================================
#define TSDB_MAX_DISK_PER_TIER 16 #define TSDB_MAX_DISK_PER_TIER 16
typedef struct {
int64_t size;
int64_t free;
} STierMeta;
typedef struct STier { typedef struct STier {
int level; int level;
int ndisk; int32_t ndisk;
SDisk *disks[TSDB_MAX_DISK_PER_TIER]; STierMeta tmeta;
SDisk * disks[TSDB_MAX_DISK_PER_TIER];
} STier; } STier;
#define DISK_AT_TIER(pTier, id) ((pTier)->disks[id]) #define TIER_LEVEL(pt) ((pt)->level)
#define TIER_NDISKS(pt) ((pt)->ndisk)
#define TIER_SIZE(pt) ((pt)->tmeta.size)
#define TIER_FREE_SIZE(pt) ((pt)->tmeta.free)
#define DISK_AT_TIER(pt, id) ((pt)->disks[id])
void tfsInitTier(STier *pTier, int level); void tfsInitTier(STier *pTier, int level);
void tfsDestroyTier(STier *pTier); void tfsDestroyTier(STier *pTier);
SDisk *tfsMountDiskToTier(STier *pTier, SDiskCfg *pCfg); SDisk *tfsMountDiskToTier(STier *pTier, SDiskCfg *pCfg);
int tfsUpdateTierInfo(STier *pTier); void tfsUpdateTierInfo(STier *pTier);
// tfs.c
void tfsIncFileAt(int level, int id);
void tfsDecFileAt(int level, int id);
int tfsLock();
int tfsUnLock();
bool tfsIsLocked();
int tfsLevels();
// tfcntl.c
#ifdef __cplusplus #ifdef __cplusplus
} }

39
src/tfs/src/tdisk.c
View File

@ -17,21 +17,8 @@
#include "taoserror.h" #include "taoserror.h"
#include "tfsint.h" #include "tfsint.h"
typedef struct {
uint64_t size;
uint64_t free;
uint64_t nfiles;
} SDiskMeta;
struct SDisk {
int level;
int id;
char dir[TSDB_FILENAME_LEN];
SDiskMeta dmeta;
};
// PROTECTED ==================================== // PROTECTED ====================================
SDisk *tfsNewDisk(int level, int id, char *dir) { SDisk *tfsNewDisk(int level, int id, const char *dir) {
SDisk *pDisk = (SDisk *)calloc(1, sizeof(*pDisk)); SDisk *pDisk = (SDisk *)calloc(1, sizeof(*pDisk));
if (pDisk == NULL) { if (pDisk == NULL) {
terrno = TSDB_CODE_FS_OUT_OF_MEMORY; terrno = TSDB_CODE_FS_OUT_OF_MEMORY;
@ -45,24 +32,24 @@ SDisk *tfsNewDisk(int level, int id, char *dir) {
return pDisk; return pDisk;
} }
void tfsFreeDisk(SDisk *pDisk) { SDisk *tfsFreeDisk(SDisk *pDisk) {
if (pDisk) { if (pDisk) {
free(pDisk); free(pDisk);
} }
return NULL;
} }
int tfsUpdateDiskInfo(SDisk *pDisk) { void tfsUpdateDiskInfo(SDisk *pDisk) {
ASSERT(pDisk != NULL);
SysDiskSize dstat; SysDiskSize dstat;
if (taosGetDiskSize(pDisk->dir, &dstat) < 0) { if (taosGetDiskSize(pDisk->dir, &dstat) < 0) {
fError("failed to get dir %s information since %s", pDisk->dir, strerror(errno)); fError("failed to update disk information at level %d id %d dir %s since %s", pDisk->level, pDisk->id, pDisk->dir,
strerror(errno));
terrno = TAOS_SYSTEM_ERROR(errno); terrno = TAOS_SYSTEM_ERROR(errno);
return -1; pDisk->dmeta.size = 0;
pDisk->dmeta.free = 0;
} else {
pDisk->dmeta.size = dstat.tsize;
pDisk->dmeta.free = dstat.avail;
} }
}
pDisk->dmeta.size = dstat.tsize;
pDisk->dmeta.free = dstat.avail;
return 0;
}
const char *tfsDiskDir(SDisk *pDisk) { return pDisk->dir; }

178
src/tfs/src/tfs.c
View File

@ -17,13 +17,14 @@
#include "hash.h" #include "hash.h"
#include "taoserror.h" #include "taoserror.h"
#include "tfs.h"
#include "tfsint.h" #include "tfsint.h"
#define TSDB_MAX_TIER 3 #define TSDB_MAX_TIER 3
typedef struct { typedef struct {
uint64_t tsize; int64_t tsize;
uint64_t avail; int64_t avail;
} SFSMeta; } SFSMeta;
typedef struct { typedef struct {
@ -35,24 +36,34 @@ typedef struct {
SHashObj * map; // name to did map SHashObj * map; // name to did map
} SFS; } SFS;
static SFS tdFileSystem = {0}; #define TFS_LOCKED() (pfs->locked)
static SFS *pfs = &tdFileSystem; #define TFS_META() (pfs->meta)
#define TFS_NLEVEL() (pfs->nlevel)
#define TFS_TIERS() (pfs->tiers)
#define TIER_AT(level) (pfs->tiers + (level)) #define TFS_TIER_AT(level) (TFS_TIERS() + (level))
#define DISK_AT(level, id) DISK_AT_TIER(TIER_AT(level), id) #define TFS_DISK_AT(level, id) DISK_AT_TIER(TFS_TIER_AT(level), id)
#define TFS_PRIMARY_DISK() TFS_DISK_AT(TFS_PRIMARY_LEVEL, TFS_PRIMARY_ID)
static int tfsMount(SDiskCfg *pCfg); static SFS tfs = {0};
static int tfsCheckAndFormatCfg(SDiskCfg *pCfg); static SFS *pfs = &tfs;
static int tfsFormatDir(char *idir, char *odir);
static int tfsCheck();
static tfsGetDiskByName(char *dirName);
// public: // STATIC DECLARATION
static int tfsMount(SDiskCfg *pCfg);
static int tfsCheck();
static int tfsCheckAndFormatCfg(SDiskCfg *pCfg);
static int tfsFormatDir(char *idir, char *odir);
static SDisk *tfsGetDiskByID(SDiskID did);
static SDisk *tfsGetDiskByName(const char *dir);
static int tfsLock();
static int tfsUnLock();
// FS APIs
int tfsInit(SDiskCfg *pDiskCfg, int ndisk) { int tfsInit(SDiskCfg *pDiskCfg, int ndisk) {
ASSERT(ndisk > 0); ASSERT(ndisk > 0);
for (int level = 0; level < TSDB_MAX_TIER; level++) { for (int level = 0; level < TSDB_MAX_TIER; level++) {
tdInitTier(TIER_AT(level), level); tfsInitTier(TFS_TIER_AT(level), level);
} }
int ret = pthread_mutex_init(&(pfs->lock), NULL); int ret = pthread_mutex_init(&(pfs->lock), NULL);
@ -81,6 +92,8 @@ int tfsInit(SDiskCfg *pDiskCfg, int ndisk) {
return -1; return -1;
} }
tfsUpdateInfo();
return 0; return 0;
} }
@ -89,39 +102,39 @@ void tfsDestroy() {
pfs->map = NULL; pfs->map = NULL;
pthread_mutex_destroy(&(pfs->lock)); pthread_mutex_destroy(&(pfs->lock));
for (int level = 0; level < TSDB_MAX_TIER; level++) { for (int level = 0; level < TFS_NLEVEL(); level++) {
tfsDestroyTier(TIER_AT(level)); tfsDestroyTier(TFS_TIER_AT(level));
} }
} }
int tfsUpdateInfo() { void tfsUpdateInfo() {
tfsLock(); tfsLock();
for (int level = 0; level < pfs->nlevel; level++) { for (int level = 0; level < TFS_NLEVEL(); level++) {
if (tfsUpdateTierInfo(TIER_AT(level)) < 0) { STier *pTier = TFS_TIER_AT(level);
// TODO: deal with the error here tfsUpdateTierInfo(pTier);
} pfs->meta.tsize = TIER_SIZE(pTier);
pfs->meta.avail = TIER_FREE_SIZE(pTier);
} }
tfsUnLock(); tfsUnLock();
} }
const char *tfsPrimaryPath() { return tfsDiskDir(DISK_AT(0, 0)); } const char *TFS_PRIMARY_PATH() { return DISK_DIR(TFS_PRIMARY_DISK()); }
const char *TFS_DISK_PATH(int level, int id) { return DISK_DIR(TFS_DISK_AT(level, id)); }
int tfsCreateDir(char *dirname) { // MANIP APIS ====================================
char dirName[TSDB_FILENAME_LEN] = "\0"; int tfsMkdir(const char *rname) {
char aname[TSDB_FILENAME_LEN] = "\0";
for (int level = 0; level < pfs->nlevel; level++) { for (int level = 0; level < TFS_NLEVEL(); level++) {
STier *pTier = TIER_AT(level); STier *pTier = TFS_TIER_AT(level);
for (int id = 0; id < pTier->ndisk; id++) { for (int id = 0; id < TIER_NDISKS(pTier); id++) {
SDisk *pDisk = DISK_AT_TIER(pTier, id); SDisk *pDisk = DISK_AT_TIER(pTier, id);
snprintf(aname, TSDB_FILENAME_LEN, "%s/%s", DISK_DIR(pDisk), rname);
ASSERT(pDisk != NULL); if (mkdir(aname, 0755) != 0 && errno != EEXIST) {
fError("failed to create directory %s since %s", aname, strerror(errno));
snprintf(dirName, TSDB_FILENAME_LEN, "%s/%s", pDisk->name, dirname);
if (mkdir(dirName, 0755) != 0 && errno != EEXIST) {
fError("failed to create directory %s since %s", dirName, strerror(errno));
terrno = TAOS_SYSTEM_ERROR(errno); terrno = TAOS_SYSTEM_ERROR(errno);
return -1; return -1;
} }
@ -131,60 +144,43 @@ int tfsCreateDir(char *dirname) {
return 0; return 0;
} }
int tfsRemoveDir(char *dirname) { int tfsRmdir(const char *rname) {
char dirName[TSDB_FILENAME_LEN] = "\0"; char aname[TSDB_FILENAME_LEN] = "\0";
for (int level = 0; level < pfs->nlevel; level++) { for (int level = 0; level < TFS_NLEVEL(); level++) {
STier *pTier = TIER_AT(level); STier *pTier = TFS_TIER_AT(level);
for (int id = 0; id < pTier->ndisk; id++) { for (int id = 0; id < TIER_NDISKS(pTier); id++) {
SDisk *pDisk = DISK_AT_TIER(pTier, id); SDisk *pDisk = DISK_AT_TIER(pTier, id);
ASSERT(pDisk != NULL); snprintf(aname, TSDB_FILENAME_LEN, "%s/%s", DISK_DIR(pDisk), rname);
snprintf(dirName, TSDB_FILENAME_LEN, "%s/%s", pDisk->dir, dirname); taosRemoveDir(aname);
taosRemoveDir(dirName);
} }
} }
return 0; return 0;
} }
int tfsRename(char *oldpath, char *newpath) { int tfsRename(char *orname, char *nrname) {
char oldName[TSDB_FILENAME_LEN] = "\0"; char oaname[TSDB_FILENAME_LEN] = "\0";
char newName[TSDB_FILENAME_LEN] = "\0"; char naname[TSDB_FILENAME_LEN] = "\0";
for (int level = 0; level < pfs->nlevel; level++) { for (int level = 0; level < pfs->nlevel; level++) {
STier *pTier = TIER_AT(level); STier *pTier = TFS_TIER_AT(level);
for (int id = 0; id < pTier->ndisk; id++) { for (int id = 0; id < TIER_NDISKS(pTier); id++) {
SDisk *pDisk = DISK_AT_TIER(pTier, id); SDisk *pDisk = DISK_AT_TIER(pTier, id);
ASSERT(pDisk != NULL); snprintf(oaname, TSDB_FILENAME_LEN, "%s/%s", DISK_DIR(pDisk), orname);
snprintf(naname, TSDB_FILENAME_LEN, "%s/%s", DISK_DIR(pDisk), nrname);
snprintf(oldName, TSDB_FILENAME_LEN, "%s/%s", pDisk->dir, oldpath); taosRename(oaname, naname);
snprintf(newName, TSDB_FILENAME_LEN, "%s/%s", pDisk->dir, newpath);
taosRename(oldName, newName);
} }
} }
return 0; return 0;
} }
// protected: static int tfsLock() {
void tfsIncFileAt(int level, int id) {
ASSERT(tfsIsLocked());
DISK_AT(level, id)->dmeta.nfiles++;
ASSERT(DISK_AT(level, id)->dmeta.nfiles > 0);
}
void tfsDecFileAt(int level, int id) {
ASSERT(tfsIsLocked());
DISK_AT(level, id)->dmeta.nfiles--;
ASSERT(DISK_AT(level, id)->dmeta.nfiles >= 0);
}
int tfsLock() {
int code = pthread_mutex_lock(&(pfs->lock)); int code = pthread_mutex_lock(&(pfs->lock));
if (code != 0) { if (code != 0) {
terrno = TAOS_SYSTEM_ERROR(code); terrno = TAOS_SYSTEM_ERROR(code);
@ -196,7 +192,7 @@ int tfsLock() {
return 0; return 0;
} }
int tfsUnLock() { static int tfsUnLock() {
pfs->locked = false; pfs->locked = false;
int code = pthread_mutex_unlock(&(pfs->lock)); int code = pthread_mutex_unlock(&(pfs->lock));
@ -208,32 +204,24 @@ int tfsUnLock() {
return 0; return 0;
} }
bool tfsIsLocked() { return pfs->locked; }
int tfsLevels() { return pfs->nlevel; }
const char *tfsGetDiskName(int level, int id) {
return DISK_AT(level, id)->dir;
}
// private // private
static int tfsMount(SDiskCfg *pCfg) { static int tfsMount(SDiskCfg *pCfg) {
SDiskID did; SDiskID did;
SDisk * pDisk = NULL;
if (tfsCheckAndFormatCfg(pCfg) < 0) return -1; if (tfsCheckAndFormatCfg(pCfg) < 0) return -1;
did.level = pCfg->level; did.level = pCfg->level;
did.id = tdMountToTier(TIER_AT(pCfg->level), pCfg); pDisk = tfsMountDiskToTier(TFS_TIER_AT(did.level), pCfg);
if (did.id < 0) { if (pDisk == NULL) {
fError("failed to mount %s to FS since %s", pCfg->dir, tstrerror(terrno)); fError("failed to mount disk %s to level %d since %s", pCfg->dir, pCfg->level, strerror(terrno));
return -1; return -1;
} }
did.id = DISK_ID(pDisk);
taosHashPut(pTiers->map, pCfg->dir, strnlen(pCfg->dir, TSDB_FILENAME_LEN), (void *)(&did), sizeof(did)); taosHashPut(pfs->map, (void *)(pCfg->dir), strnlen(pCfg->dir, TSDB_FILENAME_LEN), (void *)(&did), sizeof(did));
if (pfs->nlevel < pCfg->level + 1) pfs->nlevel = pCfg->level + 1; if (pfs->nlevel < pCfg->level + 1) pfs->nlevel = pCfg->level + 1;
// TODO: update meta info
return 0; return 0;
} }
@ -254,8 +242,8 @@ static int tfsCheckAndFormatCfg(SDiskCfg *pCfg) {
return -1; return -1;
} }
if (DISK_AT(0, 0) != NULL) { if (TFS_PRIMARY_DISK() != NULL) {
fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir, pCfg->level); fError("failed to mount %s to FS since duplicate primary mount", pCfg->dir);
terrno = TSDB_CODE_FS_DUP_PRIMARY; terrno = TSDB_CODE_FS_DUP_PRIMARY;
return -1; return -1;
} }
@ -317,25 +305,35 @@ static int tfsFormatDir(char *idir, char *odir) {
} }
static int tfsCheck() { static int tfsCheck() {
if (DISK_AT(0, 0) == NULL) { if (TFS_PRIMARY_DISK() == NULL) {
fError("no primary disk is set"); fError("no primary disk is set");
terrno = TSDB_CODE_FS_NO_PRIMARY_DISK; terrno = TSDB_CODE_FS_NO_PRIMARY_DISK;
return -1; return -1;
} }
int level = 0; for (int level = 0; level < TFS_NLEVEL(); level++) {
do { if (TIER_NDISKS(TFS_TIER_AT(level)) == 0) {
if (TIER_AT(level)->ndisk == 0) {
fError("no disk at level %d", level); fError("no disk at level %d", level);
terrno = TSDB_CODE_FS_NO_MOUNT_AT_TIER; terrno = TSDB_CODE_FS_NO_MOUNT_AT_TIER;
return -1; return -1;
} }
} while (level < pfs->nlevel); }
return 0; return 0;
} }
static tfsGetDiskByName(char *dirName) { static SDisk *tfsGetDiskByID(SDiskID did) { return TFS_DISK_AT(did.level, did.id); }
} static SDisk *tfsGetDiskByName(const char *dir) {
SDiskID did;
SDisk * pDisk = NULL;
void * pr = NULL;
static SDisk *tfsGetDiskByID(SDiskID did) { return DISK_AT(did.level, did.id); } pr = taosHashGet(pfs->map, (void *)dir, strnlen(dir, TSDB_FILENAME_LEN));
if (pr == NULL) return NULL;
did = *(SDiskID *)pr;
pDisk = tfsGetDiskByID(did);
ASSERT(pDisk != NULL);
return pDisk;
}

32
src/tfs/src/ttier.c
View File

@ -18,14 +18,11 @@
#include "taoserror.h" #include "taoserror.h"
// PROTECTED ========================================== // PROTECTED ==========================================
void tfsInitTier(STier *pTier, int level) { void tfsInitTier(STier *pTier, int level) { pTier->level = level; }
pTier->level = level;
}
void tfsDestroyTier(STier *pTier) { void tfsDestroyTier(STier *pTier) {
for (int id = 0; id < TSDB_MAX_DISK_PER_TIER; id++) { for (int id = 0; id < TSDB_MAX_DISK_PER_TIER; id++) {
tfsFreeDisk(DISK_AT_TIER(pTier, id)); DISK_AT_TIER(pTier, id) = tfsFreeDisk(DISK_AT_TIER(pTier, id));
pTier->disks[id] = NULL;
} }
pTier->ndisk = 0; pTier->ndisk = 0;
} }
@ -34,9 +31,9 @@ SDisk *tfsMountDiskToTier(STier *pTier, SDiskCfg *pCfg) {
ASSERT(pTier->level == pCfg->level); ASSERT(pTier->level == pCfg->level);
int id = 0; int id = 0;
if (pTier->ndisk >= TSDB_MAX_DISK_PER_TIER) { if (TIER_NDISKS(pTier) >= TSDB_MAX_DISK_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT; terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
return -1; return NULL;
} }
if (pTier->level == 0) { if (pTier->level == 0) {
@ -46,7 +43,7 @@ SDisk *tfsMountDiskToTier(STier *pTier, SDiskCfg *pCfg) {
id = pTier->ndisk + 1; id = pTier->ndisk + 1;
if (id >= TSDB_MAX_DISK_PER_TIER) { if (id >= TSDB_MAX_DISK_PER_TIER) {
terrno = TSDB_CODE_FS_TOO_MANY_MOUNT; terrno = TSDB_CODE_FS_TOO_MANY_MOUNT;
return -1; return NULL;
} }
} }
} else { } else {
@ -54,19 +51,22 @@ SDisk *tfsMountDiskToTier(STier *pTier, SDiskCfg *pCfg) {
} }
DISK_AT_TIER(pTier, id) = tfsNewDisk(pCfg->level, id, pCfg->dir); DISK_AT_TIER(pTier, id) = tfsNewDisk(pCfg->level, id, pCfg->dir);
if (DISK_AT_TIER(pTier, id) == NULL) return -1; if (DISK_AT_TIER(pTier, id) == NULL) return NULL;
pTier->ndisk++; pTier->ndisk++;
fDebug("disk %s is mounted to level %d id %d", pCfg->dir, pCfg->level, id); fDebug("disk %s is mounted to tier level %d id %d", pCfg->dir, pCfg->level, id);
return id; return DISK_AT_TIER(pTier, id);
} }
int tfsUpdateTierInfo(STier *pTier) { void tfsUpdateTierInfo(STier *pTier) {
STierMeta tmeta = {0};
for (int id = 0; id < pTier->ndisk; id++) { for (int id = 0; id < pTier->ndisk; id++) {
if (tfsUpdateDiskInfo(DISK_AT_TIER(pTier, id)) < 0) { tfsUpdateDiskInfo(DISK_AT_TIER(pTier, id));
return -1; tmeta.size += DISK_SIZE(DISK_AT_TIER(pTier, id));
} tmeta.free += DISK_FREE_SIZE(DISK_AT_TIER(pTier, id));
} }
return 0;
pTier->tmeta = tmeta;
} }