//读取Master的packet，删除chunk
//调用：masterconn_gotpacket()
void masterconn_delete(masterconn *eptr,const uint8_t *data,uint32_t length) {
uint64_t chunkid;
uint32_t version;
uint8_t *ptr;
#ifdef BGJOBS
void *packet;
#else /* BGJOBS */
uint8_t status;
#endif /* BGJOBS */
if (length!=8+4) {
syslog(LOG_NOTICE,"MATOCS_DELETE - wrong size (%"PRIu32"/12)",length);
eptr->mode = KILL;
return;
}
chunkid = get64bit(&data);
version = get32bit(&data);
#ifdef BGJOBS
packet = masterconn_create_detached_packet(CSTOMA_DELETE,8+1);
if (packet==NULL) {
eptr->mode=KILL;
return;
}
ptr = masterconn_get_packet_data(packet);
put64bit(&ptr,chunkid);
job_delete(eptr->jpool,masterconn_jobfinished,packet,chunkid,version);
#else /* BGJOBS */
status = hdd_delete(chunkid,version);
ptr = masterconn_create_attached_packet(eptr,CSTOMA_DELETE,8+1);
if (ptr==NULL) {
eptr->mode=KILL;
return;
}
put64bit(&ptr,chunkid);
put8bit(&ptr,status);
#endif /* BGJOBS */
}
void masterconn_reportload(void) {
masterconn *eptr = masterconnsingleton;
uint32_t load;
uint8_t hltosend;
uint8_t *buff;
if (eptr->mode==DATA && eptr->masterversion>=VERSION2INT(1,6,28) && eptr->registerstate==REGISTERED) {
load = job_getload();
if (eptr->masterversion>=VERSION2INT(3,0,7)) {
hltosend = eptr->hlstatus;
if (hltosend!=2 && hdd_is_rebalance_on()) {
hltosend = 3;
}
if (eptr->masterversion<VERSION2INT(3,0,62) && hltosend==3) {
hltosend = 2;
}
buff = masterconn_create_attached_packet(eptr,CSTOMA_CURRENT_LOAD,5);
put32bit(&buff,load);
put8bit(&buff,hltosend);
} else {
buff = masterconn_create_attached_packet(eptr,CSTOMA_CURRENT_LOAD,4);
put32bit(&buff,load);
}
}
}
void masterconn_sendregister(masterconn *eptr) {
uint8_t *buff;
eptr->downloading=0;
eptr->metafd=-1;
if (currentlogversion>0) {
buff = masterconn_createpacket(eptr,MLTOMA_REGISTER,1+4+2+8);
put8bit(&buff,2);
put16bit(&buff,VERSMAJ);
put8bit(&buff,VERSMID);
put8bit(&buff,VERSMIN);
put16bit(&buff,Timeout);
put64bit(&buff,currentlogversion);
} else {
buff = masterconn_createpacket(eptr,MLTOMA_REGISTER,1+4+2);
put8bit(&buff,1);
put16bit(&buff,VERSMAJ);
put8bit(&buff,VERSMID);
put8bit(&buff,VERSMIN);
put16bit(&buff,Timeout);
}
}
void matomlserv_download_start(matomlserventry *eptr,const uint8_t *data,uint32_t length) {
uint8_t filenum;
uint64_t size;
uint8_t *ptr;
if (length!=1) {
syslog(LOG_NOTICE,"MLTOMA_DOWNLOAD_START - wrong size (%"PRIu32"/1)",length);
eptr->mode=KILL;
return;
}
filenum = get8bit(&data);
if (filenum==1 || filenum==2) {
if (eptr->metafd>=0) {
close(eptr->metafd);
eptr->metafd=-1;
}
if (eptr->chain1fd>=0) {
close(eptr->chain1fd);
eptr->chain1fd=-1;
}
if (eptr->chain2fd>=0) {
close(eptr->chain2fd);
eptr->chain2fd=-1;
}
}
if (filenum==1) {
eptr->metafd = open("metadata.mfs.back",O_RDONLY);
eptr->chain1fd = open("changelog.0.mfs",O_RDONLY);
eptr->chain2fd = open("changelog.1.mfs",O_RDONLY);
} else if (filenum==2) {
eptr->metafd = open("sessions.mfs",O_RDONLY);
} else if (filenum==11) {
if (eptr->metafd>=0) {
close(eptr->metafd);
}
eptr->metafd = eptr->chain1fd;
eptr->chain1fd = -1;
} else if (filenum==12) {
if (eptr->metafd>=0) {
close(eptr->metafd);
}
eptr->metafd = eptr->chain2fd;
eptr->chain2fd = -1;
} else {
eptr->mode=KILL;
return;
}
if (eptr->metafd<0) {
if (filenum==11 || filenum==12) {
ptr = matomlserv_createpacket(eptr,MATOML_DOWNLOAD_START,8);
put64bit(&ptr,0);
return;
} else {
ptr = matomlserv_createpacket(eptr,MATOML_DOWNLOAD_START,1);
put8bit(&ptr,0xff); // error
return;
}
}
size = lseek(eptr->metafd,0,SEEK_END);
ptr = matomlserv_createpacket(eptr,MATOML_DOWNLOAD_START,8);
put64bit(&ptr,size); // ok
}
void matomlserv_send_old_changes(matomlserventry *eptr,uint64_t version) {
old_changes_block *oc;
old_changes_entry *oce;
uint8_t *data;
uint8_t start=0;
uint32_t i;
char logname[255];
uint64_t firstlv;
if (eptr->logf) {
matomlserv_send_archived_changes(eptr);
if (eptr->logf) {
return;
}
version=eptr->currentversion;
} else if (old_changes_head==NULL || old_changes_head->minversion>version) {
for (i=0; i<20; i++) {
sprintf(logname, "changelog.%d.mfs",i);
firstlv=findfirstlogversion(logname);
if (firstlv>version || firstlv==0) {
continue;
}
if ((eptr->logf=fopen(logname,"r"))!=NULL) {
eptr->logindex = i;
eptr->currentversion=version;
matomlserv_send_archived_changes(eptr);
if (eptr->logf) {
return;
}
version=eptr->currentversion;
} else {
syslog(LOG_WARNING, "matomlserv open %s failed", logname);
}
break;
}
}
if (old_changes_head==NULL) {
// syslog(LOG_WARNING,"meta logger wants old changes, but storage is disabled");
return;
}
if (old_changes_head->minversion>version) {
syslog(LOG_WARNING,"meta logger wants changes since version: %"PRIu64", but minimal version in storage is: %"PRIu64,version,old_changes_head->minversion);
}
for (oc=old_changes_head ; oc ; oc=oc->next) {
if (oc->minversion<=version && (oc->next==NULL || oc->next->minversion>version)) {
start=1;
}
if (start) {
for (i=0 ; i<oc->entries ; i++) {
oce = oc->old_changes_block + i;
if (version<=oce->version) {
data = matomlserv_createpacket(eptr,MATOML_METACHANGES_LOG,9+oce->length);
put8bit(&data,0xFF);
put64bit(&data,oce->version);
memcpy(data,oce->data,oce->length);
}
}
}
}
}
int main(void) {
uint64_t buff[2];
uint8_t *wp;
const uint8_t *rp;
uint32_t i;
mfstest_init();
wp = (uint8_t*)buff;
for (i=0 ; i<16 ; i++) {
wp[i] = ((15-i)*0x10)+i;
}
mfstest_start(getbit_uneven);
rp = (uint8_t*)buff;
mfstest_assert_uint8_eq(get8bit(&rp),0xF0);
mfstest_assert_uint16_eq(get16bit(&rp),0xE1D2);
mfstest_assert_uint32_eq(get32bit(&rp),0xC3B4A596);
mfstest_assert_uint64_eq(get64bit(&rp),0x8778695A4B3C2D1E);
mfstest_end();
mfstest_start(getbit_even);
rp = (uint8_t*)buff;
mfstest_assert_uint64_eq(get64bit(&rp),0xF0E1D2C3B4A59687);
mfstest_assert_uint32_eq(get32bit(&rp),0x78695A4B);
mfstest_assert_uint16_eq(get16bit(&rp),0x3C2D);
mfstest_assert_uint8_eq(get8bit(&rp),0x1E);
mfstest_end();
wp = (uint8_t*)buff;
for (i=0; i<16 ; i++) {
wp[i] = 0;
}
put8bit(&wp,0xF0);
put16bit(&wp,0xE1D2);
put32bit(&wp,0xC3B4A596);
put64bit(&wp,0x8778695A4B3C2D1E);
put8bit(&wp,0x0F);
mfstest_start(putbit_uneven);
rp = (uint8_t*)buff;
for (i=0 ; i<16 ; i++) {
mfstest_assert_uint8_eq(rp[i],((15-i)*0x10)+i);
}
mfstest_end();
wp = (uint8_t*)buff;
for (i=0; i<16 ; i++) {
wp[i] = 0;
}
put64bit(&wp,0xF0E1D2C3B4A59687);
put32bit(&wp,0x78695A4B);
put16bit(&wp,0x3C2D);
put8bit(&wp,0x1E);
put8bit(&wp,0x0F);
mfstest_start(putbit_even);
rp = (uint8_t*)buff;
for (i=0 ; i<16 ; i++) {
mfstest_assert_uint8_eq(rp[i],((15-i)*0x10)+i);
}
mfstest_end();
mfstest_return();
}
static void dir_metaentries_fill(uint8_t *buff,uint32_t ino) {
uint8_t l;
switch (ino) {
case META_ROOT_INODE:
// .
put8bit(&buff,1);
put8bit(&buff,'.');
put32bit(&buff,META_ROOT_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// ..
put8bit(&buff,2);
put8bit(&buff,'.');
put8bit(&buff,'.');
put32bit(&buff,META_ROOT_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// trash
l = strlen(META_TRASH_NAME);
put8bit(&buff,l);
memcpy(buff,META_TRASH_NAME,l);
buff+=l;
put32bit(&buff,META_TRASH_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// reserved
l = strlen(META_RESERVED_NAME);
put8bit(&buff,l);
memcpy(buff,META_RESERVED_NAME,l);
buff+=l;
put32bit(&buff,META_RESERVED_INODE);
put8bit(&buff,TYPE_DIRECTORY);
return;
case META_TRASH_INODE:
// .
put8bit(&buff,1);
put8bit(&buff,'.');
put32bit(&buff,META_TRASH_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// ..
put8bit(&buff,2);
put8bit(&buff,'.');
put8bit(&buff,'.');
put32bit(&buff,META_ROOT_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// undel
l = strlen(META_UNDEL_NAME);
put8bit(&buff,l);
memcpy(buff,META_UNDEL_NAME,l);
buff+=l;
put32bit(&buff,META_UNDEL_INODE);
put8bit(&buff,TYPE_DIRECTORY);
return;
case META_UNDEL_INODE:
// .
put8bit(&buff,1);
put8bit(&buff,'.');
put32bit(&buff,META_UNDEL_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// ..
put8bit(&buff,2);
put8bit(&buff,'.');
put8bit(&buff,'.');
put32bit(&buff,META_TRASH_INODE);
put8bit(&buff,TYPE_DIRECTORY);
return;
case META_RESERVED_INODE:
// .
put8bit(&buff,1);
put8bit(&buff,'.');
put32bit(&buff,META_RESERVED_INODE);
put8bit(&buff,TYPE_DIRECTORY);
// ..
put8bit(&buff,2);
put8bit(&buff,'.');
put8bit(&buff,'.');
put32bit(&buff,META_ROOT_INODE);
put8bit(&buff,TYPE_DIRECTORY);
return;
}
}
static void* masterproxy_server(void *args) {
uint8_t header[8];
uint8_t querybuffer[QUERYSIZE];
uint8_t ansbuffer[ANSSIZE];
uint8_t *wptr;
const uint8_t *rptr;
int sock = *((int*)args);
uint32_t psize,cmd,msgid,asize,acmd;
free(args);
for (;;) {
if (tcptoread(sock,header,8,1000)!=8) {
tcpclose(sock);
return NULL;
}
rptr = header;
cmd = get32bit(&rptr);
psize = get32bit(&rptr);
if (cmd==CLTOMA_FUSE_REGISTER) { // special case: register
// if (psize>QUERYSIZE) {
if (psize!=73) {
tcpclose(sock);
return NULL;
}
if (tcptoread(sock,querybuffer,psize,1000)!=(int32_t)(psize)) {
tcpclose(sock);
return NULL;
}
if (memcmp(querybuffer,FUSE_REGISTER_BLOB_ACL,64)!=0) {
tcpclose(sock);
return NULL;
}
if (querybuffer[64]!=REGISTER_TOOLS) {
tcpclose(sock);
return NULL;
}
wptr = ansbuffer;
put32bit(&wptr,MATOCL_FUSE_REGISTER);
put32bit(&wptr,1);
put8bit(&wptr,STATUS_OK);
if (tcptowrite(sock,ansbuffer,9,1000)!=9) {
tcpclose(sock);
return NULL;
}
} else {
if (psize<4 || psize>QUERYSIZE) {
tcpclose(sock);
return NULL;
}
if (tcptoread(sock,querybuffer,psize,1000)!=(int32_t)(psize)) {
tcpclose(sock);
return NULL;
}
rptr = querybuffer;
msgid = get32bit(&rptr);
asize = ANSSIZE-12;
if (fs_custom(cmd,querybuffer+4,psize-4,&acmd,ansbuffer+12,&asize)!=STATUS_OK) {
tcpclose(sock);
return NULL;
}
wptr = ansbuffer;
put32bit(&wptr,acmd);
put32bit(&wptr,asize+4);
put32bit(&wptr,msgid);
if (tcptowrite(sock,ansbuffer,asize+12,1000)!=(int32_t)(asize+12)) {
tcpclose(sock);
return NULL;
}
}
}
}
uint32_t sclass_info(uint8_t *buff) {
uint32_t leng,i,j,k;
uint64_t sunder,sexact,sover;
uint64_t aunder,aexact,aover;
if (buff==NULL) {
leng = 2;
for (i=1 ; i<firstneverused ; i++) {
if (sclasstab[i].nleng>0) {
leng += 20 + 3 * 16;
leng += sclasstab[i].nleng;
leng += ((uint32_t)sclasstab[i].create_labelscnt) * ( MASKORGROUP * 4 + 2 );
leng += ((uint32_t)sclasstab[i].keep_labelscnt) * ( MASKORGROUP * 4 + 2 );
leng += ((uint32_t)sclasstab[i].arch_labelscnt) * ( MASKORGROUP * 4 + 2 );
}
}
return leng;
} else {
chunk_labelset_can_be_fulfilled(0,NULL); // init server list
put16bit(&buff,matocsserv_servers_count());
for (i=1 ; i<firstneverused ; i++) {
if (sclasstab[i].nleng>0) {
put8bit(&buff,i);
put8bit(&buff,sclasstab[i].nleng);
memcpy(buff,sclasstab[i].name,sclasstab[i].nleng);
buff+=sclasstab[i].nleng;
put32bit(&buff,sclasstab[i].files);
put32bit(&buff,sclasstab[i].directories);
chunk_sclass_counters(i,0,sclasstab[i].keep_labelscnt,&sunder,&sexact,&sover);
chunk_sclass_counters(i,1,sclasstab[i].arch_labelscnt,&aunder,&aexact,&aover);
put64bit(&buff,sunder);
put64bit(&buff,aunder);
put64bit(&buff,sexact);
put64bit(&buff,aexact);
put64bit(&buff,sover);
put64bit(&buff,aover);
put8bit(&buff,sclasstab[i].admin_only);
put8bit(&buff,sclasstab[i].create_mode);
put16bit(&buff,sclasstab[i].arch_delay);
put8bit(&buff,chunk_labelset_can_be_fulfilled(sclasstab[i].create_labelscnt,sclasstab[i].create_labelmasks));
put8bit(&buff,sclasstab[i].create_labelscnt);
put8bit(&buff,chunk_labelset_can_be_fulfilled(sclasstab[i].keep_labelscnt,sclasstab[i].keep_labelmasks));
put8bit(&buff,sclasstab[i].keep_labelscnt);
put8bit(&buff,chunk_labelset_can_be_fulfilled(sclasstab[i].arch_labelscnt,sclasstab[i].arch_labelmasks));
put8bit(&buff,sclasstab[i].arch_labelscnt);
for (j=0 ; j<sclasstab[i].create_labelscnt ; j++) {
for (k=0 ; k<MASKORGROUP ; k++) {
put32bit(&buff,sclasstab[i].create_labelmasks[j][k]);
}
put16bit(&buff,matocsserv_servers_with_labelsets(sclasstab[i].create_labelmasks[j]));
}
for (j=0 ; j<sclasstab[i].keep_labelscnt ; j++) {
for (k=0 ; k<MASKORGROUP ; k++) {
put32bit(&buff,sclasstab[i].keep_labelmasks[j][k]);
}
put16bit(&buff,matocsserv_servers_with_labelsets(sclasstab[i].keep_labelmasks[j]));
}
for (j=0 ; j<sclasstab[i].arch_labelscnt ; j++) {
for (k=0 ; k<MASKORGROUP ; k++) {
put32bit(&buff,sclasstab[i].arch_labelmasks[j][k]);
}
put16bit(&buff,matocsserv_servers_with_labelsets(sclasstab[i].arch_labelmasks[j]));
}
}
}
return 0;
}
}
