66 ssize_t
pgRead (
void* buffer, off_t offset,
size_t rdlen,
67 uint32_t* csvec, uint64_t
opts) {
return rRC; }
69 ssize_t
pgWrite(
void* buffer, off_t offset,
size_t wrlen,
70 uint32_t* csvec, uint64_t
opts) {
return wRC; }
72 ssize_t
Read(off_t,
size_t) {
return rRC; }
73 ssize_t
Read(
void *, off_t,
size_t) {
return rRC; }
77 ssize_t
Write(
const void *, off_t,
size_t) {
return wRC; }
82 int Close(
long long *retsz=0) {
return -EBADF;}
101 {
return (
rRC ?
rRC :
ossP->Readdir(buff, blen));}
105 ssize_t
pgRead (
void* buffer, off_t offset,
size_t rdlen,
106 uint32_t* csvec, uint64_t
opts)
108 return ossP->pgRead(buffer,offset,rdlen,csvec,
opts);
116 ssize_t
Read(off_t offset,
size_t rlen)
118 return ossP->Read(offset, rlen);
121 ssize_t
Read(
void *buff, off_t offset,
size_t rlen)
123 return ossP->Read(buff, offset, rlen);
128 return ossP->Read(aiop);
133 return ossP->ReadV(readV, rdvcnt);
136 ssize_t
ReadRaw(
void *buff , off_t offset,
size_t rlen)
138 return ossP->ReadRaw(buff, offset, rlen);
141 int Close(
long long *retsz=0) {
return ossP->Close(retsz);}
166 void add2Q(
int doLK=1);
169 {xqCV.Lock(); Handle=0; Call=0; xTNew=0; xqCV.UnLock();}
174 {xqCV.Lock(); Call = cbP; xTNew = xtm; xqCV.UnLock();}
177 : Next(0), Handle(hP), Call(cbP), xTime(xtm), xTNew(0) {}
275 if ((hP = theTable->
Find(theKey)))
276 {hP->Path.
Links++; myMutex.UnLock();
277 if (hP->WaitLock()) {*Handle = hP;
return 0;}
278 myMutex.Lock(); hP->Path.
Links--; myMutex.UnLock();
284 if (!(retc =
Alloc(theKey, Opts, Handle))) theTable->
Add(*Handle);
303 if (!(retc =
Alloc(myKey, 0, Handle)))
304 {(*Handle)->Path.Links = 0; (*Handle)->UnLock();}
321 {
int i = minAlloc;
while(i--) {hP->Next = Free; Free = hP; hP++;}}
322 if ((hP = Free)) Free = hP->Next;
355 if ((hP = roTable.Find(theKey))) hP->Path.
Len = 0;
356 if ((hP = rwTable.Find(theKey))) hP->Path.
Len = 0;
375 {pP = Posc; Posc = 0;
376 if (pP->
xprP) {myMutex.Lock(); Path.Links--; myMutex.UnLock();}
394 static const char *Who =
"?:0.0@?", *Whc = Who+1, *Whh = Who+5;
395 const char *Col, *At;
407 if (!(Col = index(User,
':')) || !(At = index(User,
'@')))
408 {User = Who; Col = Whc; At = Whh;}
417 {
if (!strncmp(User, Posc->User, Posc->Ulen)
418 && !strcmp(Posc->User + Posc->Uhst, At+1))
return 0;
422 sprintf(buff,
"%s to %s for", Posc->User, User);
423 OfsEroute.Emsg(
"Posc",
"Creator changed from", buff, Path.Val);
424 if (Unum < 0) Unum = Posc->Unum;
425 else if (Unum != Posc->Unum) retval = Posc->Unum;
432 Posc->User = strdup(User);
433 Posc->Ulen = Col - User + 1;
434 Posc->Uhst = At - User + 1;
448 if (Posc)
return Posc->User;
470 {
if (buff)
strlcpy(buff, Path.Val, blen);
472 if ( (
isRW ? rwTable.Remove(
this) : roTable.Remove(
this)) )
473 {
if (Posc) {Posc->Recycle(); Posc = 0;}
474 if (Path.Val) {free((
void *)Path.Val); Path.Val = (
char *)
"";}
475 Path.Len = 0; mySSI = ssi; ssi = ossDF;
476 Next = Free; Free =
this;
UnLock(); myMutex.UnLock();
477 if (mySSI && mySSI != ossDF)
478 {retc = mySSI->
Close(retsz);
delete mySSI;}
480 UnLock(); myMutex.UnLock();
481 OfsEroute.Emsg(
"Retire",
"Lost handle to", buff);
483 }
else {numLeft = --Path.Links;
UnLock(); myMutex.UnLock();}
500 {
OfsEroute.Emsg(
"Retire",
"ignoring deferred retire of", Path.Val);
501 if (Path.Links != 1 || !Posc || !cbP) myMutex.UnLock();
502 else {myMutex.UnLock(); cbP->
Retired(
this);}
510 if (Posc->xprP) Posc->xprP->Set(cbP, hTime+time(0));
511 else {xP = Posc->xprP =
new XrdOfsHanXpr(
this, cbP, hTime+time(0));
524 static int InitDone = 0;
534 if (InitDone)
return InitDone == 1;
536 0,
"Handle Timeout")))
537 {
OfsEroute.Emsg(
"StartXpr", rc,
"create handle timeout thread");
538 InitDone = -1;
return 0;
540 InitDone = 1;
return 1;
552 if (hP->Posc && xP == hP->Posc->
xprP) hP->Posc->
xprP = 0;
553 else {
OfsEroute.Emsg(
"StarXtpr",
"Invalid xpr ref to", hP->Path.
Val);
554 hP->
UnLock();
delete xP;
continue;
563 if (hP->Path.
Links != 1 || !xP->Call) myMutex.UnLock();
564 else {myMutex.UnLock();
592int XrdOfsHandle::WaitLock(
void)
596 if (hMutex.
TimedLock(LockTries*LockWait))
return 1;
614 if ((pP = Free)) {Free = pP->Next; pP->Next = 0;}
631 if (User) free(User);
640 Next = Free; Free =
this;
653 prevtablesize = psize;
654 nashtablesize = csize;
655 Threshold = (csize * LoadMax) / 100;
659 memset((
void *)nashtable, 0, (
size_t)(csize*
sizeof(
XrdOfsHandle *)));
672 if (++nashnum > Threshold) Expand();
676 kent = hip->Path.
Hash % nashtablesize;
677 hip->Next = nashtable[kent];
678 nashtable[kent] = hip;
685void XrdOfsHanTab::Expand()
687 int newsize, newent, i;
693 newsize = prevtablesize + nashtablesize;
698 if (!(newtab = (
XrdOfsHandle **) malloc(memlen)))
return;
699 memset((
void *)newtab, 0, memlen);
703 for (i = 0; i < nashtablesize; i++)
706 {nextnip = nip->Next;
707 newent = nip->Path.
Hash % newsize;
708 nip->Next = newtab[newent];
709 newtab[newent] = nip;
716 free((
void *)nashtable);
718 prevtablesize = nashtablesize;
719 nashtablesize = newsize;
723 Threshold =
static_cast<int>((
static_cast<long long>(newsize)*LoadMax)/100);
737 kent = Key.
Hash%nashtablesize;
741 nip = nashtable[kent];
742 while(nip && nip->Path != Key) nip = nip->Next;
757 kent = rip->Path.
Hash%nashtablesize;
761 nip = nashtable[kent];
762 while(nip && nip != rip) {pip = nip; nip = nip->Next;}
767 {
if (pip) pip->Next = nip->Next;
768 else nashtable[kent] = nip->Next;
787 if (doLK) xqCV.Lock();
790 while(xP && xP->xTime < xTime) {xPP = xP; xP = xP->Next;}
793 if (xPP) {xPP->Next =
this;
if (doLK) xqCV.UnLock();}
794 else { xprQ =
this;
if (doLK) {xqCV.Signal(); xqCV.UnLock();}}
805 int waitTime = 2592000;
816do{
do{
if (!(xP = xprQ)) waitTime = 2592000;
817 else waitTime = xP->xTime - time(0);
818 if (waitTime > 0)
break;
823 if (!(hP = xP->Handle)) {
delete xP;
continue;}
828 {xP->xTime = xP->xTNew; xP->xTNew = 0;
836 if (!(hP->WaitLock()))
837 {
OfsEroute.Emsg(
"Retire",
"defering retire of", hP->Path.
Val);
838 xP->xTime = time(0)+30;
void * XrdOfsHanXpire(void *pp)
virtual void Retired(XrdOfsHandle *)=0
XrdOfsHanOssErr(XrdOssDF *ossp, int rrc=-EBADF, int wrc=-EBADF)
ssize_t ReadV(XrdOucIOVec *readV, int rdvcnt)
ssize_t Read(void *buff, off_t offset, size_t rlen)
int Readdir(char *buff, int blen)
int pgRead(XrdSfsAio *aioparm, uint64_t opts)
int Fstat(struct stat *Stat)
int Close(long long *retsz=0)
int Read(XrdSfsAio *aiop)
ssize_t pgRead(void *buffer, off_t offset, size_t rdlen, uint32_t *csvec, uint64_t opts)
ssize_t Read(off_t offset, size_t rlen)
ssize_t ReadRaw(void *buff, off_t offset, size_t rlen)
ssize_t ReadV(XrdOucIOVec *readV, int rdvcnt)
int Open(const char *, int, mode_t, XrdOucEnv &)
ssize_t pgRead(void *buffer, off_t offset, size_t rdlen, uint32_t *csvec, uint64_t opts)
ssize_t ReadRaw(void *, off_t, size_t)
ssize_t pgWrite(void *buffer, off_t offset, size_t wrlen, uint32_t *csvec, uint64_t opts)
ssize_t WriteV(XrdOucIOVec *writeV, int wrvcnt)
int Readdir(char *buff, int blen)
int isCompressed(char *cxidp=0)
int pgRead(XrdSfsAio *aioparm, uint64_t opts)
int Fsync(XrdSfsAio *aiop)
off_t getMmap(void **addr)
ssize_t Write(const void *, off_t, size_t)
int Read(XrdSfsAio *aiop)
int Close(long long *retsz=0)
ssize_t Read(void *, off_t, size_t)
ssize_t Read(off_t, size_t)
int Opendir(const char *, XrdOucEnv &)
int Write(XrdSfsAio *aiop)
int Ftruncate(unsigned long long)
int pgWrite(XrdSfsAio *aioparm, uint64_t opts)
XrdOfsHanOss(int rrc=-EBADF, int wrc=-EBADF)
static XrdOfsHanPsc * Alloc()
XrdOfsHandle * Find(XrdOfsHanKey &Key)
XrdOfsHanTab(int psize=987, int size=1597)
int Remove(XrdOfsHandle *rip)
void Add(XrdOfsHandle *hP)
static XrdOfsHanXpr * Get()
void Set(XrdOfsHanCB *cbP, time_t xtm)
XrdOfsHanXpr(XrdOfsHandle *hP, XrdOfsHanCB *cbP, time_t xtm)
friend class XrdOfsHandle
int Retire(int &retc, long long *retsz=0, char *buff=0, int blen=0)
static void Hide(const char *thePath)
int PoscSet(const char *User, int Unum, short Mode)
int PoscGet(short &Mode, int Done=0)
static int StartXpr(int Init=0)
friend class XrdOfsHanTab
void Suppress(int rrc=-EDOM, int wrc=-EDOM)
static int Alloc(const char *thePath, int Opts, XrdOfsHandle **Handle)
friend class XrdOfsHanXpr
virtual const char * getTID()
XrdOssDF(const char *tid="", uint16_t dftype=0, int fdnum=-1)
virtual int Close(long long *retsz=0)=0
int TimedLock(int wait_ms)
static int Run(pthread_t *, void *(*proc)(void *), void *arg, int opts=0, const char *desc=0)