void entryPack(Entry *e, uchar *p, int index) { ulong t32; int flags; p += index * VtEntrySize; U32PUT(p, e->gen); U16PUT(p+4, e->psize); U16PUT(p+6, e->dsize); flags = e->flags | ((e->depth << VtEntryDepthShift) & VtEntryDepthMask); U8PUT(p+8, flags); memset(p+9, 0, 5); U48PUT(p+14, e->size, t32); if(flags & VtEntryLocal){ if(globalToLocal(e->score) == NilBlock) abort(); memset(p+20, 0, 7); U8PUT(p+27, e->archive); U32PUT(p+28, e->snap); U32PUT(p+32, e->tag); memmove(p+36, e->score+16, 4); }else memmove(p+20, e->score, VtScoreSize); }
void vtrootpack(VtRoot *r, uchar *p) { uchar *op = p; int vers, bsize; vers = VtRootVersion; bsize = r->blocksize; if(bsize >= (1<<16)) { vers |= _VtRootVersionBig; bsize = vttobig(bsize); if(bsize < 0) sysfatal("invalid root blocksize: %#lx", r->blocksize); } U16PUT(p, vers); p += 2; memmove(p, r->name, sizeof(r->name)); p += sizeof(r->name); memmove(p, r->type, sizeof(r->type)); p += sizeof(r->type); memmove(p, r->score, VtScoreSize); p += VtScoreSize; U16PUT(p, bsize); p += 2; memmove(p, r->prev, VtScoreSize); p += VtScoreSize; assert(p-op == VtRootSize); }
void headerPack(Header *h, uchar *p) { memset(p, 0, HeaderSize); U32PUT(p, HeaderMagic); U16PUT(p+4, HeaderVersion); U16PUT(p+6, h->blockSize); U32PUT(p+8, h->super); U32PUT(p+12, h->label); U32PUT(p+16, h->data); U32PUT(p+20, h->end); }
void mbPack(MetaBlock *mb) { uchar *p; p = mb->buf; assert(!mb->botch); U32PUT(p, MetaMagic); U16PUT(p+4, mb->size); U16PUT(p+6, mb->free); U16PUT(p+8, mb->maxindex); U16PUT(p+10, mb->nindex); }
static int stringPack(char *s, uchar *p) { int n; n = strlen(s); U16PUT(p, n); memmove(p+2, s, n); return n+2; }
void dePack(DirEntry *dir, MetaEntry *me) { uchar *p; ulong t32; p = me->p; U32PUT(p, DirMagic); U16PUT(p+4, 9); /* version */ p += 6; p += stringPack(dir->elem, p); U32PUT(p, dir->entry); U32PUT(p+4, dir->gen); U32PUT(p+8, dir->mentry); U32PUT(p+12, dir->mgen); U64PUT(p+16, dir->qid, t32); p += 24; p += stringPack(dir->uid, p); p += stringPack(dir->gid, p); p += stringPack(dir->mid, p); U32PUT(p, dir->mtime); U32PUT(p+4, dir->mcount); U32PUT(p+8, dir->ctime); U32PUT(p+12, dir->atime); U32PUT(p+16, dir->mode); p += 5*4; if(dir->qidSpace){ U8PUT(p, DeQidSpace); U16PUT(p+1, 2*8); p += 3; U64PUT(p, dir->qidOffset, t32); U64PUT(p+8, dir->qidMax, t32); p += 16; } assert(p == me->p + me->size); }
void vtentrypack(VtEntry *e, uchar *p, int index) { ulong t32; int flags; uchar *op; int depth; int psize, dsize; p += index * VtEntrySize; op = p; depth = e->type&VtTypeDepthMask; flags = (e->flags&~(_VtEntryDir|_VtEntryDepthMask)); flags |= depth << _VtEntryDepthShift; if(e->type - depth == VtDirType) flags |= _VtEntryDir; U32PUT(p, e->gen); p += 4; psize = e->psize; dsize = e->dsize; if(psize >= (1<<16) || dsize >= (1<<16)) { flags |= _VtEntryBig; psize = vttobig(psize); dsize = vttobig(dsize); if(psize < 0 || dsize < 0) sysfatal("invalid entry psize/dsize: %ld/%ld", e->psize, e->dsize); } U16PUT(p, psize); p += 2; U16PUT(p, dsize); p += 2; U8PUT(p, flags); p++; memset(p, 0, 5); p += 5; U48PUT(p, e->size, t32); p += 6; memmove(p, e->score, VtScoreSize); p += VtScoreSize; assert(p-op == VtEntrySize); }
void vtrootpack(VtRoot *r, uint8_t *p) { uint8_t *op = p; U16PUT(p, VtRootVersion); p += 2; memmove(p, r->name, sizeof(r->name)); p += sizeof(r->name); memmove(p, r->type, sizeof(r->type)); p += sizeof(r->type); memmove(p, r->score, VtScoreSize); p += VtScoreSize; U16PUT(p, r->blocksize); p += 2; memmove(p, r->prev, VtScoreSize); p += VtScoreSize; assert(p-op == VtRootSize); }
void mbInsert(MetaBlock *mb, int i, MetaEntry *me) { uchar *p; int o, n; assert(mb->nindex < mb->maxindex); o = me->p - mb->buf; n = me->size; if(o+n > mb->size){ mb->free -= mb->size - o; mb->size = o + n; }else mb->free -= n; p = mb->buf + MetaHeaderSize + i*MetaIndexSize; n = (mb->nindex-i)*MetaIndexSize; memmove(p+MetaIndexSize, p, n); U16PUT(p, me->p - mb->buf); U16PUT(p+2, me->size); mb->nindex++; }
void superPack(Super *s, uchar *p) { u32int t32; memset(p, 0, SuperSize); U32PUT(p, SuperMagic); assert(s->version == SuperVersion); U16PUT(p+4, s->version); U32PUT(p+6, s->epochLow); U32PUT(p+10, s->epochHigh); U64PUT(p+14, s->qid, t32); U32PUT(p+22, s->active); U32PUT(p+26, s->next); U32PUT(p+30, s->current); memmove(p+34, s->last, VtScoreSize); memmove(p+54, s->name, sizeof(s->name)); }
static void mbCompact(MetaBlock *mb, MetaChunk *mc) { int oo, o, n, i; oo = MetaHeaderSize + mb->maxindex*MetaIndexSize; for(i=0; i<mb->nindex; i++){ o = mc[i].offset; n = mc[i].size; if(o != oo){ memmove(mb->buf + oo, mb->buf + o, n); U16PUT(mb->buf + MetaHeaderSize + mc[i].index*MetaIndexSize, oo); } oo += n; } mb->size = oo; mb->free = 0; }