/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <string.h>
-#include <errno.h>
-#ifdef AFS_NT40_ENV
-#include <stdlib.h>
-#include <fcntl.h>
-#include <winsock2.h>
-#else
-#include <sys/file.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#endif
-
-#include <dirent.h>
-#include <sys/stat.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#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 "afs/audit.h"
#include <afs/dir.h>
#include <afs/afsutil.h>
+#include <afs/com_err.h>
#include <afs/vol_prototypes.h>
#include <afs/errors.h>
extern int DoLogging;
extern struct afsconf_dir *tdir;
+extern int DoPreserveVolumeStats;
extern void LogError(afs_int32 errcode);
#endif
afs_int32 localTid = 1;
-
+
static afs_int32 VolPartitionInfo(struct rx_call *, char *pname,
struct diskPartition64 *);
static afs_int32 VolNukeVolume(struct rx_call *, afs_int32, afs_uint32);
afs_uint32);
static afs_int32 VolSetDate(struct rx_call *, afs_int32, afs_int32);
+/**
+ * Return the host address of the caller as a string.
+ *
+ * @param[in] acid incoming rx call
+ * @param[out] buffer buffer to be filled with the addess string
+ *
+ * @return address as formatted by inet_ntoa
+ */
+static_inline char *
+callerAddress(struct rx_call *acid, char *buffer)
+{
+ afs_uint32 ip = rx_HostOf(rx_PeerOf(rx_ConnectionOf(acid)));
+ return afs_inet_ntoa_r(ip, buffer);
+}
+
/* this call unlocks all of the partition locks we've set */
-int
-VPFullUnlock(void)
+int
+VPFullUnlock_r(void)
{
- register struct DiskPartition64 *tp;
+ struct DiskPartition64 *tp;
for (tp = DiskPartitionList; tp; tp = tp->next) {
if (tp->lock_fd != INVALID_FD) {
- close(tp->lock_fd); /* releases flock held on this partition */
+ OS_CLOSE(tp->lock_fd);
tp->lock_fd = INVALID_FD;
}
}
return 0;
}
+int
+VPFullUnlock(void)
+{
+ int code;
+ VOL_LOCK;
+ code = VPFullUnlock_r();
+ VOL_UNLOCK;
+ return code;
+}
+
/* get partition id from a name */
afs_int32
PartitionID(char *aname)
{
- register char tc;
- register int code = 0;
+ char tc;
+ int code = 0;
char ascii[3];
tc = *aname;
if (asize < 18)
return -1;
/* It's better using the Generic VFORMAT since otherwise we have to make changes to too many places... The 14 char limitation in names hits us again in AIX; print in field of 9 digits (still 10 for the rest), right justified with 0 padding */
- (void)afs_snprintf(aname, asize, VFORMAT, (unsigned long)avol);
+ snprintf(aname, asize, VFORMAT, (unsigned long)avol);
return 0;
}
return 0;
}
+#ifdef AFS_DEMAND_ATTACH_FS
+/* normally we should use the regular salvaging functions from the volume
+ * package, but this is a special case where we have a volume ID, but no
+ * volume structure to give the volume package */
+static void
+SalvageUnknownVolume(VolumeId volid, char *part)
+{
+ afs_int32 code;
+
+ Log("Scheduling salvage for allegedly nonexistent volume %lu part %s\n",
+ afs_printable_uint32_lu(volid), part);
+
+ code = FSYNC_VolOp(volid, part, FSYNC_VOL_FORCE_ERROR,
+ FSYNC_SALVAGE, NULL);
+ if (code) {
+ Log("SalvageUnknownVolume: error %ld trying to salvage vol %lu part %s\n",
+ afs_printable_int32_ld(code), afs_printable_uint32_lu(volid),
+ part);
+ }
+}
+#endif /* AFS_DEMAND_ATTACH_FS */
+
static struct Volume *
VAttachVolumeByName_retry(Error *ec, char *partition, char *name, int mode)
{
}
/* Adapted from the file server; create a root directory for this volume */
-static int
+static Error
ViceCreateRoot(Volume *vp)
{
DirHandle dir;
struct acl_accessList *ACL;
AFSFid did;
- Inode inodeNumber, nearInode;
+ Inode inodeNumber, AFS_UNUSED nearInode;
struct VnodeDiskObject *vnode;
struct VnodeClassInfo *vcp = &VnodeClassInfo[vLarge];
IHandle_t *h;
FdHandle_t *fdP;
- int code;
afs_fsize_t length;
+ ssize_t nBytes;
vnode = (struct VnodeDiskObject *)malloc(SIZEOF_LARGEDISKVNODE);
if (!vnode)
IH_CREATE(V_linkHandle(vp), V_device(vp),
VPartitionPath(V_partition(vp)), nearInode, V_parentId(vp),
1, 1, 0);
- assert(VALID_INO(inodeNumber));
+ if (!VALID_INO(inodeNumber)) {
+ Log("ViceCreateRoot: IH_CREATE: %s\n", afs_error_message(errno));
+ free(vnode);
+ return EIO;
+ }
SetSalvageDirHandle(&dir, V_parentId(vp), vp->device, inodeNumber);
did.Volume = V_id(vp);
did.Vnode = (VnodeId) 1;
did.Unique = 1;
- assert(!(MakeDir(&dir, (afs_int32 *)&did, (afs_int32 *)&did)));
+ osi_Assert(!(afs_dir_MakeDir(&dir, (afs_int32 *)&did, (afs_int32 *)&did)));
DFlush(); /* flush all modified dir buffers out */
- DZap((afs_int32 *)&dir); /* Remove all buffers for this dir */
- length = Length(&dir); /* Remember size of this directory */
+ DZap(&dir); /* Remove all buffers for this dir */
+ length = afs_dir_Length(&dir); /* Remember size of this directory */
FidZap(&dir); /* Done with the dir handle obtained via SetSalvageDirHandle() */
IH_INIT(h, vp->device, V_parentId(vp),
vp->vnodeIndex[vLarge].handle->ih_ino);
fdP = IH_OPEN(h);
- assert(fdP != NULL);
- code = FDH_SEEK(fdP, vnodeIndexOffset(vcp, 1), SEEK_SET);
- assert(code >= 0);
- code = FDH_WRITE(fdP, vnode, SIZEOF_LARGEDISKVNODE);
- assert(code == SIZEOF_LARGEDISKVNODE);
+ osi_Assert(fdP != NULL);
+ nBytes = FDH_PWRITE(fdP, vnode, SIZEOF_LARGEDISKVNODE, vnodeIndexOffset(vcp, 1));
+ osi_Assert(nBytes == SIZEOF_LARGEDISKVNODE);
FDH_REALLYCLOSE(fdP);
IH_RELEASE(h);
VNDISK_GET_LEN(length, vnode);
V_diskused(vp) = nBlocks(length);
free(vnode);
- return 1;
+ return 0;
}
afs_int32
-SAFSVolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition
+SAFSVolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition
*partition)
{
afs_int32 code;
}
afs_int32
-SAFSVolPartitionInfo64(struct rx_call *acid, char *pname, struct diskPartition64
+SAFSVolPartitionInfo64(struct rx_call *acid, char *pname, struct diskPartition64
*partition)
{
afs_int32 code;
}
afs_int32
-VolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition64
+VolPartitionInfo(struct rx_call *acid, char *pname, struct diskPartition64
*partition)
{
- register struct DiskPartition64 *dp;
+ struct DiskPartition64 *dp;
/*
if (!afsconf_SuperUser(tdir, acid, caller)) return VOLSERBAD_ACCESS;
char partName[50];
afs_int32 error;
Error verror;
- register afs_int32 code;
+ afs_int32 code;
struct Volume *tvp;
char caller[MAXKTCNAMELEN];
/* check for access */
if (!afsconf_SuperUser(tdir, acid, caller))
return VOLSERBAD_ACCESS;
- if (DoLogging)
- Log("%s is executing VolNukeVolume %u\n", caller, avolID);
+ if (DoLogging) {
+ char buffer[16];
+ Log("%s on %s is executing VolNukeVolume %u\n", caller,
+ callerAddress(acid, buffer), avolID);
+ }
if (volutil_PartitionName2_r(apartID, partName, sizeof(partName)) != 0)
return VOLSERNOVOL;
* Return the new volume id in *avolid.
*/
afs_int32
-SAFSVolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
- afs_int32 atype, afs_uint32 aparent, afs_uint32 *avolid,
+SAFSVolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
+ afs_int32 atype, afs_uint32 aparent, afs_uint32 *avolid,
afs_int32 *atrans)
{
afs_int32 code;
}
static afs_int32
-VolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
- afs_int32 atype, afs_uint32 aparent, afs_uint32 *avolid,
+VolCreateVolume(struct rx_call *acid, afs_int32 apart, char *aname,
+ afs_int32 atype, afs_uint32 aparent, afs_uint32 *avolid,
afs_int32 *atrans)
{
Error error;
- register Volume *vp;
+ Volume *vp;
Error junk; /* discardable error code */
afs_uint32 volumeID;
afs_int32 doCreateRoot = 1;
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char ppath[30];
char caller[MAXKTCNAMELEN];
return VOLSERBADNAME;
if (!afsconf_SuperUser(tdir, acid, caller))
return VOLSERBAD_ACCESS;
- if (DoLogging)
- Log("%s is executing CreateVolume '%s'\n", caller, aname);
+ if (DoLogging) {
+ char buffer[16];
+ Log("%s on %s is executing CreateVolume '%s'\n", caller,
+ callerAddress(acid, buffer), aname);
+ }
if ((error = ConvertPartition(apart, ppath, sizeof(ppath))))
return error; /*a standard unix error */
if (atype != readwriteVolume && atype != readonlyVolume
}
vp = VCreateVolume(&error, ppath, volumeID, aparent);
if (error) {
+#ifdef AFS_DEMAND_ATTACH_FS
+ if (error != VVOLEXISTS && error != EXDEV) {
+ SalvageUnknownVolume(volumeID, ppath);
+ }
+#endif
Log("1 Volser: CreateVolume: Unable to create the volume; aborted, error code %u\n", error);
LogError(error);
DeleteTrans(tt, 1);
V_inService(vp) = V_blessed(vp) = 1;
V_type(vp) = atype;
AssignVolumeName(&V_disk(vp), aname, 0);
- if (doCreateRoot)
- ViceCreateRoot(vp);
+ if (doCreateRoot) {
+ error = ViceCreateRoot(vp);
+ if (error) {
+ Log("1 Volser: CreateVolume: Unable to create volume root dir; "
+ "error code %u\n", (unsigned)error);
+ DeleteTrans(tt, 1);
+ V_needsSalvaged(vp) = 1;
+ VDetachVolume(&junk, vp);
+ return EIO;
+ }
+ }
V_destroyMe(vp) = DESTROY_ME;
V_inService(vp) = 0;
V_maxquota(vp) = 5000; /* set a quota of 5000 at init time */
static afs_int32
VolDeleteVolume(struct rx_call *acid, afs_int32 atrans)
{
- register struct volser_trans *tt;
+ struct volser_trans *tt;
Error error;
char caller[MAXKTCNAMELEN];
TRELE(tt);
return ENOENT;
}
- if (DoLogging)
- Log("%s is executing Delete Volume %u\n", caller, tt->volid);
+ if (DoLogging) {
+ char buffer[16];
+ Log("%s on %s is executing Delete Volume %u\n", caller,
+ callerAddress(acid, buffer), tt->volid);
+ }
TSetRxCall(tt, acid, "DeleteVolume");
VPurgeVolume(&error, tt->volume); /* don't check error code, it is not set! */
- V_destroyMe(tt->volume) = DESTROY_ME; /* so endtrans does the right fssync opcode */
+ V_destroyMe(tt->volume) = DESTROY_ME;
+ if (tt->volume->needsPutBack) {
+ tt->volume->needsPutBack = VOL_PUTBACK_DELETE; /* so endtrans does the right fssync opcode */
+ }
VTRANS_OBJ_LOCK(tt);
tt->vflags |= VTDeleted; /* so we know not to do anything else to it */
TClearRxCall_r(tt);
*/
/* for efficiency reasons, sometimes faster to piggyback a purge here */
afs_int32
-SAFSVolClone(struct rx_call *acid, afs_int32 atrans, afs_uint32 purgeId,
+SAFSVolClone(struct rx_call *acid, afs_int32 atrans, afs_uint32 purgeId,
afs_int32 newType, char *newName, afs_uint32 *newNumber)
{
afs_int32 code;
}
static afs_int32
-VolClone(struct rx_call *acid, afs_int32 atrans, afs_uint32 purgeId,
+VolClone(struct rx_call *acid, afs_int32 atrans, afs_uint32 purgeId,
afs_int32 newType, char *newName, afs_uint32 *newNumber)
{
afs_uint32 newId;
- register struct Volume *originalvp, *purgevp, *newvp;
+ struct Volume *originalvp, *purgevp, *newvp;
Error error, code;
- register struct volser_trans *tt, *ttc;
+ struct volser_trans *tt, *ttc;
char caller[MAXKTCNAMELEN];
+#ifdef AFS_DEMAND_ATTACH_FS
+ struct Volume *salv_vp = NULL;
+#endif
if (strlen(newName) > 31)
return VOLSERBADNAME;
if (!afsconf_SuperUser(tdir, acid, caller))
return VOLSERBAD_ACCESS; /*not a super user */
- if (DoLogging)
- Log("%s is executing Clone Volume new name=%s\n", caller, newName);
+ if (DoLogging) {
+ char buffer[16];
+ Log("%s on %s is executing Clone Volume new name=%s\n", caller,
+ callerAddress(acid, buffer), newName);
+ }
error = 0;
originalvp = (Volume *) 0;
purgevp = (Volume *) 0;
}
newId = *newNumber;
- if (newType != readonlyVolume && newType != backupVolume)
- return EINVAL;
tt = FindTrans(atrans);
if (!tt)
return ENOENT;
purgevp = NULL;
}
originalvp = tt->volume;
- if ((V_type(originalvp) == backupVolume)
- || (V_type(originalvp) == readonlyVolume)) {
- Log("1 Volser: Clone: The volume to be cloned must be a read/write; aborted\n");
- error = EROFS;
- goto fail;
- }
if ((V_destroyMe(originalvp) == DESTROY_ME) || !V_inService(originalvp)) {
Log("1 Volser: Clone: Volume %d is offline and cannot be cloned\n",
V_id(originalvp));
error = EINVAL;
goto fail;
}
- if (V_type(originalvp) == readonlyVolume
- && V_parentId(originalvp) != V_parentId(purgevp)) {
- Log("1 Volser: Clone: Volume %u and volume %u were not cloned from the same parent volume; aborted\n", tt->volid, purgeId);
- error = EXDEV;
- goto fail;
- }
- if (V_type(originalvp) == readwriteVolume
- && tt->volid != V_parentId(purgevp)) {
- Log("1 Volser: Clone: Volume %u was not originally cloned from volume %u; aborted\n", purgeId, tt->volid);
+ if (V_parentId(originalvp) != V_parentId(purgevp)) {
+ Log("1 Volser: Clone: Volume %u and volume %u were not originally cloned from the same parent; aborted\n", purgeId, tt->volid);
error = EXDEV;
goto fail;
}
}
error = 0;
+#ifdef AFS_DEMAND_ATTACH_FS
+ salv_vp = originalvp;
+#endif
- newvp =
- VCreateVolume(&error, originalvp->partition->name, newId,
- V_parentId(originalvp));
- if (error) {
- Log("1 Volser: Clone: Couldn't create new volume; clone aborted\n");
- newvp = (Volume *) 0;
- goto fail;
+ if (purgeId == newId) {
+ newvp = purgevp;
+ } else {
+ newvp =
+ VCreateVolume(&error, originalvp->partition->name, newId,
+ V_parentId(originalvp));
+ if (error) {
+ Log("1 Volser: Clone: Couldn't create new volume; clone aborted\n");
+ newvp = (Volume *) 0;
+ goto fail;
+ }
}
if (newType == readonlyVolume)
V_cloneId(originalvp) = newId;
goto fail;
}
TClearRxCall(tt);
+#ifdef AFS_DEMAND_ATTACH_FS
+ salv_vp = NULL;
+#endif
if (TRELE(tt)) {
tt = (struct volser_trans *)0;
error = VOLSERTRELE_ERROR;
}
if (ttc)
DeleteTrans(ttc, 1);
+#ifdef AFS_DEMAND_ATTACH_FS
+ if (salv_vp && error != VVOLEXISTS && error != EXDEV) {
+ V_needsSalvaged(salv_vp) = 1;
+ }
+#endif /* AFS_DEMAND_ATTACH_FS */
return error;
}
static afs_int32
VolReClone(struct rx_call *acid, afs_int32 atrans, afs_int32 cloneId)
{
- register struct Volume *originalvp, *clonevp;
+ struct Volume *originalvp, *clonevp;
Error error, code;
afs_int32 newType;
- register struct volser_trans *tt, *ttc;
+ struct volser_trans *tt, *ttc;
char caller[MAXKTCNAMELEN];
+ VolumeDiskData saved_header;
/*not a super user */
if (!afsconf_SuperUser(tdir, acid, caller))
return VOLSERBAD_ACCESS;
- if (DoLogging)
- Log("%s is executing Reclone Volume %u\n", caller, cloneId);
+ if (DoLogging) {
+ char buffer[16];
+ Log("%s on %s is executing Reclone Volume %u\n", caller,
+ callerAddress(acid, buffer), cloneId);
+ }
error = 0;
clonevp = originalvp = (Volume *) 0;
tt = (struct volser_trans *)0;
TSetRxCall(tt, acid, "ReClone");
originalvp = tt->volume;
- if ((V_type(originalvp) == backupVolume)
- || (V_type(originalvp) == readonlyVolume)) {
- Log("1 Volser: Clone: The volume to be cloned must be a read/write; aborted\n");
- error = EROFS;
- goto fail;
- }
if ((V_destroyMe(originalvp) == DESTROY_ME) || !V_inService(originalvp)) {
Log("1 Volser: Clone: Volume %d is offline and cannot be cloned\n",
V_id(originalvp));
error = EXDEV;
goto fail;
}
- if (V_type(clonevp) != readonlyVolume && V_type(clonevp) != backupVolume) {
- Log("1 Volser: Clone: The \"recloned\" volume must be a read only volume; aborted\n");
- error = EINVAL;
- goto fail;
- }
- if (V_type(originalvp) == readonlyVolume
- && V_parentId(originalvp) != V_parentId(clonevp)) {
- Log("1 Volser: Clone: Volume %u and volume %u were not cloned from the same parent volume; aborted\n", tt->volid, cloneId);
- error = EXDEV;
- goto fail;
- }
- if (V_type(originalvp) == readwriteVolume
- && tt->volid != V_parentId(clonevp)) {
+ if (V_parentId(originalvp) != V_parentId(clonevp)) {
Log("1 Volser: Clone: Volume %u was not originally cloned from volume %u; aborted\n", cloneId, tt->volid);
error = EXDEV;
goto fail;
}
+ if (DoPreserveVolumeStats) {
+ CopyVolumeStats(&V_disk(clonevp), &saved_header);
+ }
+
error = 0;
Log("1 Volser: Clone: Recloning volume %u to volume %u\n", tt->volid,
cloneId);
}
/* don't do strcpy onto diskstuff.name, it's still OK from 1st clone */
- /* pretend recloned volume is a totally new instance */
- V_copyDate(clonevp) = time(0);
- V_creationDate(clonevp) = V_copyDate(clonevp);
- ClearVolumeStats(&V_disk(clonevp));
+ /* update the creationDate, since this represents the last cloning date
+ * for ROs. But do not update copyDate; let it stay so we can identify
+ * when the clone was first created. */
+ V_creationDate(clonevp) = time(0);
+ if (DoPreserveVolumeStats) {
+ CopyVolumeStats(&saved_header, &V_disk(clonevp));
+ } else {
+ ClearVolumeStats(&V_disk(clonevp));
+ }
V_destroyMe(clonevp) = 0;
V_inService(clonevp) = 0;
if (newType == backupVolume) {
- V_backupDate(originalvp) = V_copyDate(clonevp);
- V_backupDate(clonevp) = V_copyDate(clonevp);
+ V_backupDate(originalvp) = V_creationDate(clonevp);
+ V_backupDate(clonevp) = V_creationDate(clonevp);
}
V_inUse(clonevp) = 0;
VUpdateVolume(&error, clonevp);
LogError(error);
goto fail;
}
- /* VUpdateVolume succeeded. Mark it in service so there's no window
- * between FSYNC_VOL_ON and VolSetFlags where it's offline with no
- * specialStatus; this is a reclone and this volume started online
+ /* VUpdateVolume succeeded. Mark it in service so there's no window
+ * between FSYNC_VOL_ON and VolSetFlags where it's offline with no
+ * specialStatus; this is a reclone and this volume started online
*/
V_inService(clonevp) = 1;
VDetachVolume(&error, clonevp); /* allow file server to get it's hands on it */
VolTransCreate(struct rx_call *acid, afs_uint32 volume, afs_int32 partition,
afs_int32 iflags, afs_int32 *ttid)
{
- register struct volser_trans *tt;
- register Volume *tv;
+ struct volser_trans *tt;
+ Volume *tv;
afs_int32 error;
Error code;
afs_int32 mode;
static afs_int32
VolGetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 *aflags)
{
- register struct volser_trans *tt;
+ struct volser_trans *tt;
tt = FindTrans(atid);
if (!tt)
static afs_int32
VolSetFlags(struct rx_call *acid, afs_int32 atid, afs_int32 aflags)
{
- register struct volser_trans *tt;
- register struct Volume *vp;
+ struct volser_trans *tt;
+ struct Volume *vp;
Error error;
char caller[MAXKTCNAMELEN];
*/
afs_int32
SAFSVolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
- struct destServer *destination, afs_int32 destTrans,
+ struct destServer *destination, afs_int32 destTrans,
struct restoreCookie *cookie)
{
afs_int32 code;
code =
VolForward(acid, fromTrans, fromDate, destination, destTrans, cookie);
osi_auditU(acid, VS_ForwardEvent, code, AUD_LONG, fromTrans, AUD_HOST,
- destination->destHost, AUD_LONG, destTrans, AUD_END);
+ htonl(destination->destHost), AUD_LONG, destTrans, AUD_END);
return code;
}
static afs_int32
VolForward(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
- struct destServer *destination, afs_int32 destTrans,
+ struct destServer *destination, afs_int32 destTrans,
struct restoreCookie *cookie)
{
- register struct volser_trans *tt;
- register afs_int32 code;
- register struct rx_connection *tcon;
+ struct volser_trans *tt;
+ afs_int32 code;
+ struct rx_connection *tcon;
struct rx_call *tcall;
- register struct Volume *vp;
+ struct Volume *vp;
struct rx_securityClass *securityObject;
afs_int32 securityIndex;
char caller[MAXKTCNAMELEN];
/* Start a dump and send it to multiple places simultaneously.
* If this returns an error (eg, return ENOENT), it means that
- * none of the releases worked. If this returns 0, that means
+ * none of the releases worked. If this returns 0, that means
* that one or more of the releases worked, and the caller has
* to examine the results array to see which one(s).
* This will only do EITHER incremental or full, not both, so it's
* the caller's responsibility to be sure that all the destinations
- * need just an incremental (and from the same time), if that's
- * what we're doing.
+ * need just an incremental (and from the same time), if that's
+ * what we're doing.
*/
afs_int32
-SAFSVolForwardMultiple(struct rx_call *acid, afs_int32 fromTrans, afs_int32
+SAFSVolForwardMultiple(struct rx_call *acid, afs_int32 fromTrans, afs_int32
fromDate, manyDests *destinations, afs_int32 spare,
struct restoreCookie *cookie, manyResults *results)
{
i = results->manyResults_len = destinations->manyDests_len;
results->manyResults_val = codes =
(afs_int32 *) malloc(i * sizeof(afs_int32));
- }
+ }
if (!results || !results->manyResults_val)
return ENOMEM;
}
osi_auditU(acid, VS_ForwardEvent, (code ? code : codes[i]), AUD_LONG,
- fromTrans, AUD_HOST, dest->server.destHost, AUD_LONG,
+ fromTrans, AUD_HOST, htonl(dest->server.destHost), AUD_LONG,
dest->trans, AUD_END);
}
free(tcons);
afs_int32 flags)
{
int code = 0;
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(tdir, acid, caller))
return 0;
}
-/*
+/*
* Ha! No more helper process!
*/
afs_int32
VolRestore(struct rx_call *acid, afs_int32 atrans, afs_int32 aflags,
struct restoreCookie *cookie)
{
- register struct volser_trans *tt;
- register afs_int32 code, tcode;
+ struct volser_trans *tt;
+ afs_int32 code, tcode;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(tdir, acid, caller))
static afs_int32
VolEndTrans(struct rx_call *acid, afs_int32 destTrans, afs_int32 *rcode)
{
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(tdir, acid, caller))
code = VolSetForwarding(acid, atid, anewsite);
osi_auditU(acid, VS_SetForwEvent, code, AUD_LONG, atid, AUD_HOST,
- anewsite, AUD_END);
+ htonl(anewsite), AUD_END);
return code;
}
static afs_int32
VolSetForwarding(struct rx_call *acid, afs_int32 atid, afs_int32 anewsite)
{
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
char partName[16];
afs_int32
SAFSVolGetStatus(struct rx_call *acid, afs_int32 atrans,
- register struct volser_status *astatus)
+ struct volser_status *astatus)
{
afs_int32 code;
static afs_int32
VolGetStatus(struct rx_call *acid, afs_int32 atrans,
- register struct volser_status *astatus)
+ struct volser_status *astatus)
{
- register struct Volume *tv;
- register struct VolumeDiskData *td;
+ struct Volume *tv;
+ struct VolumeDiskData *td;
struct volser_trans *tt;
afs_int32
SAFSVolSetInfo(struct rx_call *acid, afs_int32 atrans,
- register struct volintInfo *astatus)
+ struct volintInfo *astatus)
{
afs_int32 code;
static afs_int32
VolSetInfo(struct rx_call *acid, afs_int32 atrans,
- register struct volintInfo *astatus)
+ struct volintInfo *astatus)
{
- register struct Volume *tv;
- register struct VolumeDiskData *td;
+ struct Volume *tv;
+ struct VolumeDiskData *td;
struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
Error error;
static afs_int32
VolGetName(struct rx_call *acid, afs_int32 atrans, char **aname)
{
- register struct Volume *tv;
- register struct VolumeDiskData *td;
+ struct Volume *tv;
+ struct VolumeDiskData *td;
struct volser_trans *tt;
- register int len;
+ int len;
/* We need to at least fill it in */
*aname = (char *)malloc(1);
if (dp)
partList.partId[j++] = i;
}
- pEntries->partEntries_val = (afs_int32 *) malloc(j * sizeof(int));
- if (!pEntries->partEntries_val)
- return ENOMEM;
- memcpy((char *)pEntries->partEntries_val, (char *)&partList,
- j * sizeof(int));
- pEntries->partEntries_len = j;
+ if (j > 0) {
+ pEntries->partEntries_val = (afs_int32 *) malloc(j * sizeof(int));
+ if (!pEntries->partEntries_val)
+ return ENOMEM;
+ memcpy((char *)pEntries->partEntries_val, (char *)&partList,
+ j * sizeof(int));
+ pEntries->partEntries_len = j;
+ } else {
+ pEntries->partEntries_val = NULL;
+ pEntries->partEntries_len = 0;
+ }
return 0;
}
-/*extract the volume id from string vname. Its of the form " V0*<id>.vol "*/
-afs_int32
-ExtractVolId(char vname[])
-{
- int i;
- char name[VOLSER_MAXVOLNAME + 1];
-
- strcpy(name, vname);
- i = 0;
- while (name[i] == 'V' || name[i] == '0')
- i++;
-
- name[11] = '\0'; /* smash the "." */
- return (atol(&name[i]));
-}
-
/*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
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);
+ *volid = VolumeNumber(dp->d_name);
strcpy(volname, dp->d_name);
return 0; /*return the name of the file representing a volume */
} else {
FillVolInfo(Volume * vp, volint_info_handle_t * handle)
{
unsigned int numStatBytes, now;
- register struct VolumeDiskData *hdr = &vp->header->diskstuff;
+ struct VolumeDiskData *hdr = &vp->header->diskstuff;
/*read in the relevant info */
strcpy((char *)VOLINT_INFO_PTR(handle, name), hdr->name);
* -- tkeiser 11/27/2007
*/
- /* Conditions that offline status is based on:
+ /* Conditions that offline status is based on:
volume is unattached state
volume state is in (one of several error states)
volume not in service
volume is not marked as blessed (not on hold)
volume in salvage req. state
- volume needsSalvaged
+ volume needsSalvaged
next op would set volume offline
next op would not leave volume online (based on several conditions)
*/
(V_attachState(vp) == VOL_STATE_UNATTACHED) ||
VIsErrorState(V_attachState(vp)) ||
!hdr->inService ||
- !hdr->blessed ||
+ !hdr->blessed ||
(V_attachState(vp) == VOL_STATE_SALVSYNC_REQ) ||
hdr->needsSalvaged ||
- (vp->pending_vol_op &&
- (vp->pending_vol_op->com.command == FSYNC_VOL_OFF ||
+ (vp->pending_vol_op &&
+ (vp->pending_vol_op->com.command == FSYNC_VOL_OFF ||
!VVolOpLeaveOnline_r(vp, vp->pending_vol_op) )
)
) {
#ifdef AFS_DEMAND_ATTACH_FS
/* see comment above where we set inUse bit */
- if (hdr->needsSalvaged ||
+ if (hdr->needsSalvaged ||
(vp && VIsErrorState(V_attachState(vp)))) {
handle->volinfo_ptr.base->needsSalvaged = 1;
} else {
#endif
handle->volinfo_ptr.base->destroyMe = hdr->destroyMe;
handle->volinfo_ptr.base->spare0 = hdr->minquota;
- handle->volinfo_ptr.base->spare1 =
+ handle->volinfo_ptr.base->spare1 =
(long)hdr->weekUse[0] +
(long)hdr->weekUse[1] +
(long)hdr->weekUse[2] +
0, numStatBytes);
} else {
memcpy((char *)&(handle->volinfo_ptr.ext->stat_reads[0]),
- (char *)&(hdr->stat_reads[0]),
+ (char *)&(hdr->stat_reads[0]),
numStatBytes);
}
break;
*
* @param[in] volumeId volumeId for which we want state information
* @param[in] pname partition name string
- * @param[inout] vp pointer to pointer to Volume object which
+ * @param[inout] vp pointer to pointer to Volume object which
* will be populated (see note)
*
* @return operation status
static int
GetVolInfo(afs_uint32 partId,
afs_uint32 volumeId,
- char * pname,
- char * volname,
+ char * pname,
+ char * volname,
volint_info_handle_t * handle,
vol_info_list_mode_t mode)
{
}
/* Get volume from volserver */
- tv = VAttachVolumeByName_retry(&error, pname, volname, V_PEEK);
+ if (mode == VOL_INFO_LIST_MULTIPLE)
+ tv = VAttachVolumeByName(&error, pname, volname, V_PEEK);
+ else
+ tv = VAttachVolumeByName_retry(&error, pname, volname, V_PEEK);
if (error) {
- Log("1 Volser: GetVolInfo: Could not attach volume %u (%s:%s) error=%d\n",
+ Log("1 Volser: GetVolInfo: Could not attach volume %u (%s:%s) error=%d\n",
volumeId, pname, volname, error);
goto drop;
}
goto drop;
case VOL_INFO_LIST_SINGLE:
- Log("1 Volser: GetVolInfo: Volume %u (%s:%s) will be destroyed on next salvage\n",
+ Log("1 Volser: GetVolInfo: Volume %u (%s:%s) will be destroyed on next salvage\n",
volumeId, pname, volname);
default:
if (tv->header->diskstuff.needsSalvaged) {
/*this volume will be salvaged */
- Log("1 Volser: GetVolInfo: Volume %u (%s:%s) needs to be salvaged\n",
+ Log("1 Volser: GetVolInfo: Volume %u (%s:%s) needs to be salvaged\n",
volumeId, pname, volname);
}
}
/* fs_tv is a shallow copy, must populate certain structures before passing along */
- if (FSYNC_VolOp(volumeId, pname, FSYNC_VOL_QUERY_VOP, 0, &fs_res) == SYNC_OK) {
+ if (FSYNC_VolOp(volumeId, pname, FSYNC_VOL_QUERY_VOP, 0, &fs_res) == SYNC_OK) {
/* If we if the pending vol op */
memcpy(&pending_vol_op_res, fs_res.payload.buf, sizeof(FSSYNC_VolOp_info));
fs_tv->pending_vol_op=&pending_vol_op_res;
/* When using DAFS, use the fs volume info, populated with required structures */
fill_tv = fs_tv;
-#else
+#else
/* When not using DAFS, just use the local volume info */
fill_tv = tv;
#endif
/*return the header information about the <volid> */
afs_int32
-SAFSVolListOneVolume(struct rx_call *acid, afs_int32 partid,
+SAFSVolListOneVolume(struct rx_call *acid, afs_int32 partid,
afs_uint32 volumeId, volEntries *volumeInfo)
{
afs_int32 code;
}
static afs_int32
-VolListOneVolume(struct rx_call *acid, afs_int32 partid,
+VolListOneVolume(struct rx_call *acid, afs_int32 partid,
afs_uint32 volumeId, volEntries *volumeInfo)
{
- volintInfo *pntr;
struct DiskPartition64 *partP;
char pname[9], volname[20];
DIR *dirp;
return ENOMEM;
memset(volumeInfo->volEntries_val, 0, sizeof(volintInfo)); /* Clear structure */
- pntr = volumeInfo->volEntries_val;
volumeInfo->volEntries_len = 1;
if (GetPartName(partid, pname))
return VOLSERILLEGAL_PARTITION;
handle.volinfo_type = VOLINT_INFO_TYPE_BASE;
handle.volinfo_ptr.base = volumeInfo->volEntries_val;
-
- code = GetVolInfo(partid,
- volid,
- pname,
+
+ code = GetVolInfo(partid,
+ volid,
+ pname,
volname,
&handle,
VOL_INFO_LIST_SINGLE);
}
closedir(dirp);
- return (found) ? 0 : ENODEV;
+ if (found)
+ return code ? ENODEV: 0;
+ else
+ return ENODEV;
}
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
afs_int32
-SAFSVolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
+SAFSVolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
afs_uint32 a_volID, volXEntries *a_volumeXInfoP)
{
afs_int32 code;
}
static afs_int32
-VolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
+VolXListOneVolume(struct rx_call *a_rxCidP, afs_int32 a_partID,
afs_uint32 a_volID, volXEntries *a_volumeXInfoP)
{ /*SAFSVolXListOneVolume */
- volintXInfo *xInfoP; /*Ptr to the extended vol info */
struct DiskPartition64 *partP; /*Ptr to partition */
char pname[9], volname[20]; /*Partition, volume names */
DIR *dirp; /*Partition directory ptr */
return ENOMEM;
memset(a_volumeXInfoP->volXEntries_val, 0, sizeof(volintXInfo)); /* Clear structure */
- xInfoP = a_volumeXInfoP->volXEntries_val;
a_volumeXInfoP->volXEntries_len = 1;
code = ENODEV;
* return the proper value.
*/
closedir(dirp);
- return (found) ? 0 : ENODEV;
+ if (found)
+ return code ? ENODEV: 0;
+ else
+ return ENODEV;
} /*SAFSVolXListOneVolume */
-/*returns all the volumes on partition partid. If flags = 1 then all the
+/*returns all the volumes on partition partid. If flags = 1 then all the
* relevant info about the volumes is also returned */
afs_int32
-SAFSVolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
+SAFSVolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
volEntries *volumeInfo)
{
afs_int32 code;
}
static afs_int32
-VolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
+VolListVolumes(struct rx_call *acid, afs_int32 partid, afs_int32 flags,
volEntries *volumeInfo)
{
volintInfo *pntr;
(volintInfo *) realloc((char *)volumeInfo->volEntries_val,
allocSize * sizeof(volintInfo));
if (pntr == NULL) {
- closedir(dirp);
+ closedir(dirp);
return VOLSERNO_MEMORY;
}
volumeInfo->volEntries_val = pntr; /* point to new block */
pntr->callValid = 0;
if (tt->rxCallPtr) { /*record call related info */
pntr->callValid = 1;
+#if 0
pntr->readNext = tt->rxCallPtr->rnext;
pntr->transmitNext = tt->rxCallPtr->tnext;
pntr->lastSendTime = tt->rxCallPtr->lastSendTime;
pntr->lastReceiveTime = tt->rxCallPtr->lastReceiveTime;
+#endif
}
VTRANS_OBJ_UNLOCK(tt);
pntr++;
{
struct Volume *tv;
Error error = 0;
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
if (strlen(name) > 31)
{
struct Volume *tv;
Error error = 0;
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(tdir, acid, caller))
#else
char caller[MAXKTCNAMELEN];
DIR *dirp;
- register struct volser_trans *ttc;
+ struct volser_trans *ttc;
char pname[16], volname[20];
struct DiskPartition64 *partP;
afs_int32 ret = ENODEV;
GetNextVol(dirp, volname, &volid);
continue; /*back to while loop */
}
-
+
if (volid == volumeId) { /*copy other things too */
#ifndef AFS_PTHREAD_ENV
IOMGR_Poll(); /*make sure that the client doesnot time out */
}
GetNextVol(dirp, volname, &volid);
}
-
+
if (ttc) {
DeleteTrans(ttc, 1);
ttc = (struct volser_trans *)0;
}
-
+
closedir(dirp);
return ret;
#endif
afs_int32
SAFSVolGetSize(struct rx_call *acid, afs_int32 fromTrans, afs_int32 fromDate,
- register struct volintSize *size)
+ struct volintSize *size)
{
int code = 0;
- register struct volser_trans *tt;
+ struct volser_trans *tt;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(tdir, acid, caller))
char caller[MAXKTCNAMELEN];
char line[128];
- if (!afsconf_SuperUser(tdir, acall, caller))
+ if (!afsconf_SuperUser(tdir, acall, caller))
return EPERM;
vol = VAttachVolume(&code, vid, V_VOLUPD);
code = ENOENT;
return code;
}
- if (V_device(vol) != V_device(newvol)
+ if (V_device(vol) != V_device(newvol)
|| V_uniquifier(newvol) != 2) {
if (V_device(vol) != V_device(newvol)) {
sprintf(line, "Volumes %u and %u are not in the same partition, aborted.\n",
VDetachVolume(&code2, vol);
VDetachVolume(&code2, newvol);
return VOLSERVOLBUSY;
- }
+ }
VTRANS_OBJ_LOCK(tt);
tt->iflags = ITBusy;
tt->vflags = 0;
VDetachVolume(&code2, vol);
VDetachVolume(&code2, newvol);
return VOLSERVOLBUSY;
- }
+ }
VTRANS_OBJ_LOCK(tt2);
tt2->iflags = ITBusy;
tt2->vflags = 0;
git://git.openafs.org / openafs.git / blobdiff