#include <rx/rxkad.h>
#include <afs/afsint.h>
#include <signal.h>
+#ifdef AFS_PTHREAD_ENV
+#include <assert.h>
+#else /* AFS_PTHREAD_ENV */
#include <afs/assert.h>
+#endif /* AFS_PTHREAD_ENV */
#include <afs/prs_fs.h>
#include <afs/nfs.h>
#include <lwp.h>
#include "volser.h"
#include "volint.h"
-#include <volser_prototypes.h>
+#include "volser_prototypes.h"
extern int DoLogging;
extern struct volser_trans *FindTrans(), *NewTrans(), *TransList();
extern struct afsconf_dir *tdir;
+
+/* Needed by Irix. Leave, or include a header */
extern char *volutil_PartitionName();
extern void LogError(afs_int32 errcode);
VolDeleteVolume(), VolClone();
afs_int32 VolReClone(), VolTransCreate(), VolGetNthVolume(), VolGetFlags(),
VolForward(), VolDump();
-afs_int32 VolForwardMultiple();
afs_int32 VolRestore(), VolEndTrans(), VolSetForwarding(), VolGetStatus(),
VolSetInfo(), VolGetName();
-afs_int32 VolSignalRestore(), VolListPartitions(), VolListOneVolume(),
+afs_int32 VolListPartitions(), VolListOneVolume(),
VolXListOneVolume(), VolXListVolumes();
afs_int32 VolListVolumes(), XVolListPartitions(), VolMonitor(),
VolSetIdsTypes(), VolSetDate(), VolSetFlags();
/* this call unlocks all of the partition locks we've set */
+int
VPFullUnlock()
{
register struct DiskPartition *tp;
/* get partition id from a name */
afs_int32
-PartitionID(aname)
- char *aname;
+PartitionID(char *aname)
{
register char tc;
register int code = 0;
}
static int
-ConvertVolume(avol, aname, asize)
- afs_int32 avol;
- char *aname;
- afs_int32 asize;
+ConvertVolume(afs_int32 avol, char *aname, afs_int32 asize)
{
if (asize < 18)
return -1;
}
static int
-ConvertPartition(apartno, aname, asize)
- int apartno;
- char *aname;
- int asize;
+ConvertPartition(int apartno, char *aname, int asize)
{
if (asize < 10)
return E2BIG;
/* the only attach function that takes a partition is "...ByName", so we use it */
struct Volume *
-XAttachVolume(error, avolid, apartid, amode)
- afs_int32 *error;
- afs_int32 avolid;
- afs_int32 apartid;
- int amode;
+XAttachVolume(afs_int32 *error, afs_int32 avolid, afs_int32 apartid, int amode)
{
char pbuf[30], vbuf[20];
register struct Volume *tv;
}
/* Adapted from the file server; create a root directory for this volume */
-static
-ViceCreateRoot(vp)
- Volume *vp;
+static int
+ViceCreateRoot(Volume *vp)
{
DirHandle dir;
struct acl_accessList *ACL;
}
afs_int32
-SAFSVolPartitionInfo(acid, pname, partition)
- struct rx_call *acid;
- char *pname;
- struct diskPartition *partition;
+SAFSVolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition
+ *partition)
{
afs_int32 code;
}
afs_int32
-VolPartitionInfo(acid, pname, partition)
- struct rx_call *acid;
- char *pname;
- struct diskPartition *partition;
+VolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition
+ *partition)
{
register struct DiskPartition *dp;
/* obliterate a volume completely, and slowly. */
afs_int32
-SAFSVolNukeVolume(acid, apartID, avolID)
- struct rx_call *acid;
- afs_int32 apartID, avolID;
+SAFSVolNukeVolume(struct rx_call *acid, afs_int32 apartID, afs_int32 avolID)
{
afs_int32 code;
}
afs_int32
-VolNukeVolume(acid, apartID, avolID)
- struct rx_call *acid;
- afs_int32 apartID, avolID;
+VolNukeVolume(struct rx_call *acid, afs_int32 apartID, afs_int32 avolID)
{
register char *tp;
char partName[50];
* Return the new volume id in *avolid.
*/
afs_int32
-SAFSVolCreateVolume(acid, apart, aname, atype, aparent, avolid, atrans)
- struct rx_call *acid;
- afs_int32 apart;
- afs_int32 atype;
- char *aname;
- afs_int32 aparent;
- afs_int32 *atrans;
- afs_int32 *avolid;
+SAFSVolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
+ afs_int32 atype, afs_int32 aparent, afs_int32 *avolid,
+ afs_int32 *atrans)
{
afs_int32 code;
}
afs_int32
-VolCreateVolume(acid, apart, aname, atype, aparent, avolid, atrans)
- struct rx_call *acid;
- afs_int32 apart;
- afs_int32 atype;
- char *aname;
- afs_int32 aparent;
- afs_int32 *atrans;
- afs_int32 *avolid;
+VolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
+ afs_int32 atype, afs_int32 aparent, afs_int32 *avolid,
+ afs_int32 *atrans)
{
afs_int32 error;
register Volume *vp;
if (error) {
Log("1 Volser: CreateVolume: Unable to create the volume; aborted, error code %u\n", error);
LogError(error);
- DeleteTrans(tt);
+ DeleteTrans(tt, 1);
return EIO;
}
V_uniquifier(vp) = 1;
if (error) {
Log("1 Volser: create UpdateVolume failed, code %d\n", error);
LogError(error);
- DeleteTrans(tt);
+ DeleteTrans(tt, 1);
VDetachVolume(&junk, vp); /* rather return the real error code */
return error;
}
/* delete the volume associated with this transaction */
afs_int32
-SAFSVolDeleteVolume(acid, atrans)
- afs_int32 atrans;
- struct rx_call *acid;
+SAFSVolDeleteVolume(struct rx_call *acid, afs_int32 atrans)
{
afs_int32 code;
}
afs_int32
-VolDeleteVolume(acid, atrans)
- afs_int32 atrans;
- struct rx_call *acid;
+VolDeleteVolume(struct rx_call *acid, afs_int32 atrans)
{
register struct volser_trans *tt;
afs_int32 error;
* the same, while doing them separately would result in far more iincs and idecs being
* peformed (and they are slow operations).
*/
+/* for efficiency reasons, sometimes faster to piggyback a purge here */
afs_int32
-SAFSVolClone(acid, atrans, purgeId, newType, newName, newNumber)
- struct rx_call *acid;
- afs_int32 atrans;
- afs_int32 newType;
- afs_int32 *newNumber;
- afs_int32 purgeId; /* for efficiency reasons, sometimes faster to piggyback a purge here */
- char *newName;
+SAFSVolClone(struct rx_call *acid, afs_int32 atrans, afs_int32 purgeId,
+ afs_int32 newType, char *newName, afs_int32 *newNumber)
{
afs_int32 code;
}
afs_int32
-VolClone(acid, atrans, purgeId, newType, newName, newNumber)
- struct rx_call *acid;
- afs_int32 atrans;
- afs_int32 newType;
- afs_int32 *newNumber;
- afs_int32 purgeId; /* for efficiency reasons, sometimes faster to piggyback a purge here */
- char *newName;
+VolClone(struct rx_call *acid, afs_int32 atrans, afs_int32 purgeId,
+ afs_int32 newType, char *newName, afs_int32 *newNumber)
{
VolumeId newId;
register struct Volume *originalvp, *purgevp, *newvp;
error = VOLSERTRELE_ERROR;
goto fail;
}
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
return 0;
fail:
TRELE(tt);
}
if (ttc)
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
return error;
}
/* reclone this volume into the specified id */
afs_int32
-SAFSVolReClone(acid, atrans, cloneId)
- struct rx_call *acid;
- afs_int32 atrans;
- afs_int32 cloneId;
+SAFSVolReClone(struct rx_call *acid, afs_int32 atrans, afs_int32 cloneId)
{
afs_int32 code;
}
afs_int32
-VolReClone(acid, atrans, cloneId)
- struct rx_call *acid;
- afs_int32 atrans;
- afs_int32 cloneId;
+VolReClone(struct rx_call *acid, afs_int32 atrans, afs_int32 cloneId)
{
register struct Volume *originalvp, *clonevp;
Error error, code;
goto fail;
}
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
{
struct DiskPartition *tpartp = originalvp->partition;
TRELE(tt);
}
if (ttc)
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
return error;
}
* See volser.h for definition of iflags (the constants are named IT*).
*/
afs_int32
-SAFSVolTransCreate(acid, volume, partition, iflags, ttid)
- struct rx_call *acid;
- afs_int32 volume;
- afs_int32 partition;
- afs_int32 iflags;
- afs_int32 *ttid;
+SAFSVolTransCreate(struct rx_call *acid, afs_int32 volume, afs_int32 partition,
+ afs_int32 iflags, afs_int32 *ttid)
{
afs_int32 code;
}
afs_int32
-VolTransCreate(acid, volume, partition, iflags, ttid)
- struct rx_call *acid;
- afs_int32 volume;
- afs_int32 partition;
- afs_int32 iflags;
- afs_int32 *ttid;
+VolTransCreate(struct rx_call *acid, afs_int32 volume, afs_int32 partition,
+ afs_int32 iflags, afs_int32 *ttid)
{
register struct volser_trans *tt;
register Volume *tv;
/* give up */
if (tv)
VDetachVolume(&code, tv);
- DeleteTrans(tt);
+ DeleteTrans(tt, 1);
return error;
}
tt->volume = tv;
* Both the volume number and partition number (one-based) are returned.
*/
afs_int32
-SAFSVolGetNthVolume(acid, aindex, avolume, apart)
- struct rx_call *acid;
- afs_int32 aindex;
- afs_int32 *avolume;
- afs_int32 *apart;
+SAFSVolGetNthVolume(struct rx_call *acid, afs_int32 aindex, afs_int32 *avolume,
+ afs_int32 *apart)
{
afs_int32 code;
}
afs_int32
-VolGetNthVolume(acid, aindex, avolume, apart)
- struct rx_call *acid;
- afs_int32 aindex;
- afs_int32 *avolume;
- afs_int32 *apart;
+VolGetNthVolume(struct rx_call *acid, afs_int32 aindex, afs_int32 *avolume,
+ afs_int32 *apart)
{
Log("1 Volser: GetNthVolume: Not yet implemented\n");
return VOLSERNO_OP;
* transaction.
*/
afs_int32
-SAFSVolGetFlags(acid, atid, aflags)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 *aflags;
+SAFSVolGetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 *aflags)
{
afs_int32 code;
}
afs_int32
-VolGetFlags(acid, atid, aflags)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 *aflags;
+VolGetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 *aflags)
{
register struct volser_trans *tt;
* remains attached as usual by the transaction.
*/
afs_int32
-SAFSVolSetFlags(acid, atid, aflags)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 aflags;
+SAFSVolSetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 aflags)
{
afs_int32 code;
}
afs_int32
-VolSetFlags(acid, atid, aflags)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 aflags;
+VolSetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 aflags)
{
register struct volser_trans *tt;
register struct Volume *vp;
* specified by the destServer structure.
*/
afs_int32
-SAFSVolForward(acid, fromTrans, fromDate, destination, destTrans, cookie)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
- struct destServer *destination;
- struct restoreCookie *cookie;
- afs_int32 destTrans;
+SAFSVolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
+ struct destServer *destination, afs_int32 destTrans,
+ struct restoreCookie *cookie)
{
afs_int32 code;
}
afs_int32
-VolForward(acid, fromTrans, fromDate, destination, destTrans, cookie)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
- struct destServer *destination;
- struct restoreCookie *cookie;
- afs_int32 destTrans;
+VolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
+ struct destServer *destination, afs_int32 destTrans,
+ struct restoreCookie *cookie)
{
register struct volser_trans *tt;
register afs_int32 code;
* what we're doing.
*/
afs_int32
-SAFSVolForwardMultiple(acid, fromTrans, fromDate, destinations, spare, cookie,
- results)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
- afs_int32 spare;
- manyDests *destinations;
- struct restoreCookie *cookie;
- manyResults *results;
+SAFSVolForwardMultiple(struct rx_call *acid, afs_int32 fromTrans, afs_int32
+ fromDate, manyDests *destinations, afs_int32 spare,
+ struct restoreCookie *cookie, manyResults *results)
{
afs_int32 securityIndex;
struct rx_securityClass *securityObject;
struct rx_connection **tcons;
struct rx_call **tcalls;
struct Volume *vp;
- int i, nconns, is_incremental;
+ int i, is_incremental;
if (results)
memset(results, 0, sizeof(manyResults));
}
afs_int32
-SAFSVolDump(acid, fromTrans, fromDate)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
+SAFSVolDump(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate)
{
afs_int32 code;
}
afs_int32
-VolDump(acid, fromTrans, fromDate)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
+VolDump(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate)
{
int code = 0;
register struct volser_trans *tt;
* Ha! No more helper process!
*/
afs_int32
-SAFSVolRestore(acid, atrans, aflags, cookie)
- struct rx_call *acid;
- afs_int32 aflags;
- afs_int32 atrans;
- struct restoreCookie *cookie;
+SAFSVolRestore(struct rx_call *acid, afs_int32 atrans, afs_int32 aflags,
+ struct restoreCookie *cookie)
{
afs_int32 code;
}
afs_int32
-VolRestore(acid, atrans, aflags, cookie)
- struct rx_call *acid;
- int aflags;
- afs_int32 atrans;
- struct restoreCookie *cookie;
+VolRestore(struct rx_call *acid, afs_int32 atrans, afs_int32 aflags,
+ struct restoreCookie *cookie)
{
register struct volser_trans *tt;
register afs_int32 code, tcode;
}
strcpy(tt->lastProcName, "Restore");
tt->rxCallPtr = acid;
+
+ DFlushVolume(V_parentId(tt->volume)); /* Ensure dir buffers get dropped */
+
code = RestoreVolume(acid, tt->volume, (aflags & 1), cookie); /* last is incrementalp */
FSYNC_askfs(tt->volid, NULL, FSYNC_RESTOREVOLUME, 0l); /*break call backs on the
* restored volume */
/* end a transaction, returning the transaction's final error code in rcode */
afs_int32
-SAFSVolEndTrans(acid, destTrans, rcode)
- struct rx_call *acid;
- afs_int32 destTrans;
- afs_int32 *rcode;
+SAFSVolEndTrans(struct rx_call *acid, afs_int32 destTrans, afs_int32 *rcode)
{
afs_int32 code;
}
afs_int32
-VolEndTrans(acid, destTrans, rcode)
- struct rx_call *acid;
- afs_int32 destTrans;
- afs_int32 *rcode;
+VolEndTrans(struct rx_call *acid, afs_int32 destTrans, afs_int32 *rcode)
{
register struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
return ENOENT;
}
*rcode = tt->returnCode;
- DeleteTrans(tt); /* this does an implicit TRELE */
+ DeleteTrans(tt, 1); /* this does an implicit TRELE */
return 0;
}
afs_int32
-SAFSVolSetForwarding(acid, atid, anewsite)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 anewsite;
+SAFSVolSetForwarding(struct rx_call *acid, afs_int32 atid, afs_int32 anewsite)
{
afs_int32 code;
}
afs_int32
-VolSetForwarding(acid, atid, anewsite)
- struct rx_call *acid;
- afs_int32 atid;
- afs_int32 anewsite;
+VolSetForwarding(struct rx_call *acid, afs_int32 atid, afs_int32 anewsite)
{
-
register struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
}
afs_int32
-SAFSVolGetStatus(acid, atrans, astatus)
- struct rx_call *acid;
- afs_int32 atrans;
- register struct volser_status *astatus;
+SAFSVolGetStatus(struct rx_call *acid, afs_int32 atrans,
+ register struct volser_status *astatus)
{
afs_int32 code;
}
afs_int32
-VolGetStatus(acid, atrans, astatus)
- struct rx_call *acid;
- afs_int32 atrans;
- register struct volser_status *astatus;
+VolGetStatus(struct rx_call *acid, afs_int32 atrans,
+ register struct volser_status *astatus)
{
register struct Volume *tv;
register struct VolumeDiskData *td;
}
afs_int32
-SAFSVolSetInfo(acid, atrans, astatus)
- struct rx_call *acid;
- afs_int32 atrans;
- register struct volintInfo *astatus;
+SAFSVolSetInfo(struct rx_call *acid, afs_int32 atrans,
+ register struct volintInfo *astatus)
{
afs_int32 code;
}
afs_int32
-VolSetInfo(acid, atrans, astatus)
- struct rx_call *acid;
- afs_int32 atrans;
- register struct volintInfo *astatus;
+VolSetInfo(struct rx_call *acid, afs_int32 atrans,
+ register struct volintInfo *astatus)
{
register struct Volume *tv;
register struct VolumeDiskData *td;
afs_int32
-SAFSVolGetName(acid, atrans, aname)
- struct rx_call *acid;
- afs_int32 atrans;
- char **aname;
+SAFSVolGetName(struct rx_call *acid, afs_int32 atrans, char **aname)
{
afs_int32 code;
}
afs_int32
-VolGetName(acid, atrans, aname)
- struct rx_call *acid;
- afs_int32 atrans;
- char **aname;
+VolGetName(struct rx_call *acid, afs_int32 atrans, char **aname)
{
register struct Volume *tv;
register struct VolumeDiskData *td;
/*this is a handshake to indicate that the next call will be SAFSVolRestore
* - a noop now !*/
afs_int32
-SAFSVolSignalRestore(acid, volname, volType, parentId, cloneId)
- struct rx_call *acid;
- char volname[];
- afs_int32 parentId, cloneId;
- int volType;
+SAFSVolSignalRestore(struct rx_call *acid, char volname[], int volType,
+ afs_int32 parentId, afs_int32 cloneId)
{
return 0;
}
/*return a list of all partitions on the server. The non mounted
*partitions are returned as -1 in the corresponding slot in partIds*/
afs_int32
-SAFSVolListPartitions(acid, partIds)
- struct rx_call *acid;
- struct pIDs *partIds;
+SAFSVolListPartitions(struct rx_call *acid, struct pIDs *partIds)
{
afs_int32 code;
}
afs_int32
-VolListPartitions(acid, partIds)
- struct rx_call *acid;
- struct pIDs *partIds;
+VolListPartitions(struct rx_call *acid, struct pIDs *partIds)
{
char namehead[9];
- int code;
char i;
strcpy(namehead, "/vicep"); /*7 including null terminator */
/*return a list of all partitions on the server. The non mounted
*partitions are returned as -1 in the corresponding slot in partIds*/
afs_int32
-SAFSVolXListPartitions(acid, pEntries)
- struct rx_call *acid;
- struct partEntries *pEntries;
+SAFSVolXListPartitions(struct rx_call *acid, struct partEntries *pEntries)
{
afs_int32 code;
}
afs_int32
-XVolListPartitions(acid, pEntries)
- struct rx_call *acid;
- struct partEntries *pEntries;
+XVolListPartitions(struct rx_call *acid, struct partEntries *pEntries)
{
struct stat rbuf, pbuf;
char namehead[9];
/*extract the volume id from string vname. Its of the form " V0*<id>.vol "*/
afs_int32
-ExtractVolId(vname)
- char vname[];
+ExtractVolId(char vname[])
{
int i;
char name[VOLSER_MAXVOLNAME + 1];
/*return the name of the next volume header in the directory associated with dirp and dp.
*the volume id is returned in volid, and volume header name is returned in volname*/
+int
GetNextVol(DIR * dirp, char *volname, afs_int32 * volid)
{
struct dirent *dp;
dp = readdir(dirp); /*read next entry in the directory */
if (dp) {
-
if ((dp->d_name[0] == 'V') && !strcmp(&(dp->d_name[11]), VHDREXT)) {
*volid = ExtractVolId(dp->d_name);
strcpy(volname, dp->d_name);
/*return the header information about the <volid> */
afs_int32
-SAFSVolListOneVolume(acid, partid, volumeId, volumeInfo)
- struct rx_call *acid;
- afs_int32 volumeId, partid;
- volEntries *volumeInfo;
+SAFSVolListOneVolume(struct rx_call *acid, afs_int32 partid, afs_int32
+ volumeId, volEntries *volumeInfo)
{
afs_int32 code;
}
afs_int32
-VolListOneVolume(acid, partid, volumeId, volumeInfo)
- struct rx_call *acid;
- afs_int32 volumeId, partid;
- volEntries *volumeInfo;
+VolListOneVolume(struct rx_call *acid, afs_int32 partid, afs_int32
+ volumeId, volEntries *volumeInfo)
{
volintInfo *pntr;
register struct Volume *tv;
if (volid == volumeId) { /*copy other things too */
found = 1;
+#ifndef AFS_PTHREAD_ENV
IOMGR_Poll(); /*make sure that the client doesnot time out */
+#endif
ttc = NewTrans(volid, partid);
if (!ttc) {
pntr->status = VBUSY;
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
*------------------------------------------------------------------------*/
afs_int32
-SAFSVolXListOneVolume(a_rxCidP, a_partID, a_volID, a_volumeXInfoP)
- struct rx_call *a_rxCidP;
- afs_int32 a_partID;
- afs_int32 a_volID;
- volXEntries *a_volumeXInfoP;
+SAFSVolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
+ afs_int32 a_volID, volXEntries *a_volumeXInfoP)
{
afs_int32 code;
}
afs_int32
-VolXListOneVolume(a_rxCidP, a_partID, a_volID, a_volumeXInfoP)
- struct rx_call *a_rxCidP;
- afs_int32 a_partID;
- afs_int32 a_volID;
- volXEntries *a_volumeXInfoP;
-
+VolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
+ afs_int32 a_volID, volXEntries *a_volumeXInfoP)
{ /*SAFSVolXListOneVolume */
volintXInfo *xInfoP; /*Ptr to the extended vol info */
* doesn't time out) and to set up a transaction on the volume.
*/
found = 1;
+#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
+#endif
ttc = NewTrans(currVolID, a_partID);
if (!ttc) {
/*
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
/*returns all the volumes on partition partid. If flags = 1 then all the
* relevant info about the volumes is also returned */
afs_int32
-SAFSVolListVolumes(acid, partid, flags, volumeInfo)
- struct rx_call *acid;
- afs_int32 flags, partid;
- volEntries *volumeInfo;
+SAFSVolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
+ volEntries *volumeInfo)
{
afs_int32 code;
}
afs_int32
-VolListVolumes(acid, partid, flags, volumeInfo)
- struct rx_call *acid;
- afs_int32 flags, partid;
- volEntries *volumeInfo;
+VolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
+ volEntries *volumeInfo)
{
volintInfo *pntr;
register struct Volume *tv;
}
if (flags) { /*copy other things too */
+#ifndef AFS_PTHREAD_ENV
IOMGR_Poll(); /*make sure that the client doesnot time out */
+#endif
ttc = NewTrans(volid, partid);
if (!ttc) {
pntr->status = VBUSY;
drop:
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
pntr++;
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
closedir(dirp);
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
GetNextVol(dirp, volname, &volid);
}
closedir(dirp);
if (ttc)
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
return 0;
}
*------------------------------------------------------------------------*/
afs_int32
-SAFSVolXListVolumes(a_rxCidP, a_partID, a_flags, a_volumeXInfoP)
- struct rx_call *a_rxCidP;
- afs_int32 a_partID;
- afs_int32 a_flags;
- volXEntries *a_volumeXInfoP;
+SAFSVolXListVolumes(struct rx_call *a_rxCidP, afs_int32 a_partID,
+ afs_int32 a_flags, volXEntries *a_volumeXInfoP)
{
afs_int32 code;
}
afs_int32
-VolXListVolumes(a_rxCidP, a_partID, a_flags, a_volumeXInfoP)
- struct rx_call *a_rxCidP;
- afs_int32 a_partID;
- afs_int32 a_flags;
- volXEntries *a_volumeXInfoP;
-
+VolXListVolumes(struct rx_call *a_rxCidP, afs_int32 a_partID,
+ afs_int32 a_flags, volXEntries *a_volumeXInfoP)
{ /*SAFSVolXListVolumes */
volintXInfo *xInfoP; /*Ptr to the extended vol info */
* Full info about the volume desired. Poll to make sure the
* client doesn't time out, then start up a new transaction.
*/
+#ifndef AFS_PTHREAD_ENV
IOMGR_Poll();
+#endif
ttc = NewTrans(volid, a_partID);
if (!ttc) {
/*
* Drop the transaction we have for this volume.
*/
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
closedir(dirp);
tv = (Volume *) 0;
}
if (ttc) {
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
GetNextVol(dirp, volname, &volid);
*/
closedir(dirp);
if (ttc)
- DeleteTrans(ttc);
+ DeleteTrans(ttc, 1);
return (0);
} /*SAFSVolXListVolumes */
/*this call is used to monitor the status of volser for debugging purposes.
*information about all the active transactions is returned in transInfo*/
afs_int32
-SAFSVolMonitor(acid, transInfo)
- struct rx_call *acid;
- transDebugEntries *transInfo;
+SAFSVolMonitor(struct rx_call *acid, transDebugEntries *transInfo)
{
afs_int32 code;
}
afs_int32
-VolMonitor(acid, transInfo)
- struct rx_call *acid;
- transDebugEntries *transInfo;
+VolMonitor(struct rx_call *acid, transDebugEntries *transInfo)
{
transDebugInfo *pntr;
afs_int32 allocSize = 50;
}
afs_int32
-SAFSVolSetIdsTypes(acid, atid, name, type, pId, cloneId, backupId)
- struct rx_call *acid;
- afs_int32 type, pId, cloneId, backupId, atid;
- char name[];
+SAFSVolSetIdsTypes(struct rx_call *acid, afs_int32 atid, char name[], afs_int32 type, afs_int32 pId, afs_int32 cloneId, afs_int32 backupId)
{
afs_int32 code;
}
afs_int32
-VolSetIdsTypes(acid, atid, name, type, pId, cloneId, backupId)
- struct rx_call *acid;
- afs_int32 type, pId, cloneId, backupId, atid;
- char name[];
+VolSetIdsTypes(struct rx_call *acid, afs_int32 atid, char name[], afs_int32 type, afs_int32 pId, afs_int32 cloneId, afs_int32 backupId)
{
struct Volume *tv;
afs_int32 error = 0;
}
afs_int32
-SAFSVolSetDate(acid, atid, cdate)
- struct rx_call *acid;
- afs_int32 atid, cdate;
+SAFSVolSetDate(struct rx_call *acid, afs_int32 atid, afs_int32 cdate)
{
afs_int32 code;
}
afs_int32
-VolSetDate(acid, atid, cdate)
- struct rx_call *acid;
- afs_int32 atid, cdate;
+VolSetDate(struct rx_call *acid, afs_int32 atid, afs_int32 cdate)
{
struct Volume *tv;
afs_int32 error = 0;
#endif /* AFS_NAMEI_ENV */
afs_int32
-SAFSVolConvertROtoRWvolume(acid, partId, volumeId)
- struct rx_call *acid;
- afs_int32 partId;
- afs_int32 volumeId;
+SAFSVolConvertROtoRWvolume(struct rx_call *acid, afs_int32 partId,
+ afs_int32 volumeId)
{
#if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
DIR *dirp;
}
afs_int32
-SAFSVolGetSize(acid, fromTrans, fromDate, size)
- struct rx_call *acid;
- afs_int32 fromTrans;
- afs_int32 fromDate;
- register struct volintSize *size;
+SAFSVolGetSize(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
+ register struct volintSize *size)
{
int code = 0;
register struct volser_trans *tt;
git://git.openafs.org / openafs.git / blobdiff