if (code) goto skip_krb5_init;
}
- memset((char *)&increds, 0, sizeof(increds));
+ memset(&increds, 0, sizeof(increds));
code = pkrb5_cc_get_principal(ctx, cc, &client_principal);
if (code) {
void cm_InitReq(cm_req_t *reqp)
{
- memset((char *)reqp, 0, sizeof(cm_req_t));
+ memset(reqp, 0, sizeof(cm_req_t));
reqp->startTime = GetTickCount();
}
ListAddrByAttributes attrs;
afsUUID uuid;
- memset((char *)&attrs, 0, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
attrs.uuid = uvldbEntry.serverNumber[i];
- memset((char *)&uuid, 0, sizeof(uuid));
- memset((char *)&addrs, 0, sizeof(addrs));
+ memset(&uuid, 0, sizeof(uuid));
+ memset(&addrs, 0, sizeof(addrs));
do {
struct rx_connection *rxconnp;
localNCB = 1;
}
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
extra = 2 * (*inp->wctp); /* space used by parms, in bytes */
tp = inp->wctp + 1+ extra; /* points to count of data bytes */
send1:
ncbp = outp->ncbp;
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
ncbp->ncb_length = (unsigned short) finalCount;
ncbp->ncb_lsn = (unsigned char) vcp->lsn;
smbShutdownFlag = 1;
/* Hang up all sessions */
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
for (i = 1; i < numSessions; i++)
{
if (dead_sessions[i])
}
/* Delete Netbios name */
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
for (i = 0; i < lana_list.length; i++) {
if (lana_list.lana[i] == LANA_INVALID) continue;
ncbp->ncb_command = NCBDELNAME;
}
ncbp = outp->ncbp;
- memset((char *)ncbp, 0, sizeof(NCB));
+ memset(ncbp, 0, sizeof(NCB));
ncbp->ncb_length = (unsigned short) leftToCopy;
ncbp->ncb_lsn = (unsigned char) vcp->lsn;
client_principal = 0;
}
- memset((char *)&increds, 0, sizeof(increds));
+ memset(&increds, 0, sizeof(increds));
if ((r = krb5_build_principal(context, &increds.server,
(int)strlen(realm), realm,
if (!(r = khm_krb5_initialize(identity, &context, &k5cc))) {
int i;
- memset((char *)&increds, 0, sizeof(increds));
+ memset(&increds, 0, sizeof(increds));
pkrb5_cc_get_principal(context, k5cc, &client_principal);
i = krb5_princ_realm(context, client_principal)->length;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
afs_osi_cred.cr_ref++;
afs_osi_cred.cr_ngroups = 1;
afs_osicred_initialized = 1;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
osi_Panic("afs: cannot create SEMA Hashtable\n");
/* initialize the hash table and associated locks */
- memset((char *)hashTable, 0, sizeOfHashTable * sizeof(Bucket));
+ memset(hashTable, 0, sizeOfHashTable * sizeof(Bucket));
for (i = 0; i < sizeOfHashTable; i++)
hashLockInit(hashTable[i].lock);
hashLockInit(afsHashLock);
osi_Panic("afs: SEMA Hashtable cannot create new entry\n");
/* create new entry */
ptr->key = key;
- memset((char *)&ptr->element, 0, sizeof(ptr->element));
+ memset(&ptr->element, 0, sizeof(ptr->element));
ptr->refCnt = 1; /* this guy */
/* insert new entry in bucket */
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
return EINVAL; /* sorry */
cr = crdup(OSI_GET_CURRENT_CRED()); /* we will replace all the groups. */
- memset((char *)&cr->cr_groups, 0, ngroups_max * sizeof(gid_t));
+ memset(&cr->cr_groups, 0, ngroups_max * sizeof(gid_t));
/* Now cobble the new groups list together. */
new = 0;
}
} else
createdDir = 1;
- memset((char *)&dattr, 0, sizeof(dattr));
+ memset(&dattr, 0, sizeof(dattr));
dattr.atd_version = AFS_XFS_ATD_VERS;
dattr.atd_volume = rw_vno;
AFS_VOP_ATTR_SET(dvp, AFS_XFS_DATTR, (char *)&dattr,
return code;
}
- memset((char *)&attrs, 0, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.at_pino = vattr.va_nodeid;
VN_RELE(dvp);
}
if (!code) {
- memset((char *)&data, 0, sizeof(data));
+ memset(&data, 0, sizeof(data));
data.ili_info.inodeNumber = inode;
data.ili_info.byteCount = vattr.va_size;
data.ili_info.linkCount = (vattr.va_mode & AFS_XFS_MODE_LINK_MASK);
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
struct AFS_FLOCK flock;
/* Convert to a lock format afs_lockctl understands. */
- memset((char *)&flock, 0, sizeof(flock));
+ memset(&flock, 0, sizeof(flock));
flock.l_type = flp->fl_type;
flock.l_pid = flp->fl_pid;
flock.l_whence = 0;
cred_t *credp = crref();
struct AFS_FLOCK flock;
/* Convert to a lock format afs_lockctl understands. */
- memset((char *)&flock, 0, sizeof(flock));
+ memset(&flock, 0, sizeof(flock));
flock.l_type = flp->fl_type;
flock.l_pid = flp->fl_pid;
flock.l_whence = 0;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
#endif
/* Convert to a lock format afs_lockctl understands. */
- memset((char *)&flock, 0, sizeof(flock));
+ memset(&flock, 0, sizeof(flock));
flock.l_type = flp->fl_type;
flock.l_pid = flp->fl_pid;
flock.l_whence = 0;
cred_t *credp = crref();
struct AFS_FLOCK flock;
/* Convert to a lock format afs_lockctl understands. */
- memset((char *)&flock, 0, sizeof(flock));
+ memset(&flock, 0, sizeof(flock));
flock.l_type = flp->fl_type;
flock.l_pid = flp->fl_pid;
flock.l_whence = 0;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- memset((char *)&afs_osi_cred, 0, sizeof(afs_ucred_t));
+ memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
timecounter = 1;
for (i = 0; i < PHSIZE; i++)
phTable[i] = 0;
- memset((char *)&afs_bufferLock, 0, sizeof(afs_lock_t));
+ memset(&afs_bufferLock, 0, sizeof(afs_lock_t));
}
}
{
register int i;
- memset((char *)cbHashT, 0, CBHTSIZE * sizeof(struct bucket));
+ memset(cbHashT, 0, CBHTSIZE * sizeof(struct bucket));
for (i = 0; i < CBHTSIZE; i++) {
QInit(&(cbHashT[i].head));
/* Lock_Init(&(cbHashT[i].lock)); only if you want lots of locks, which
aflags &= ~CNoSUID;
} else {
tc = (struct cell *)afs_osi_Alloc(sizeof(struct cell));
- memset((char *)tc, 0, sizeof(*tc));
+ memset(tc, 0, sizeof(*tc));
tc->cellName = afs_strdup(acellName);
tc->fsport = AFS_FSPORT;
tc->vlport = AFS_VLPORT;
tc->states |= aflags;
tc->timeout = timeout;
- memset((char *)tc->cellHosts, 0, sizeof(tc->cellHosts));
+ memset(tc->cellHosts, 0, sizeof(tc->cellHosts));
for (i = 0; i < MAXCELLHOSTS; i++) {
/* Get server for each host and link this cell in.*/
struct server *ts;
*/
UpgradeSToWLock(&afs_xconn, 37);
tc = (struct afs_conn *)afs_osi_Alloc(sizeof(struct afs_conn));
- memset((char *)tc, 0, sizeof(struct afs_conn));
+ memset(tc, 0, sizeof(struct afs_conn));
tc->user = tu;
tc->port = aport;
/* initialize subsystem */
if (brsInit == 0) {
LOCK_INIT(&afs_xbrs, "afs_xbrs");
- memset((char *)afs_brs, 0, sizeof(afs_brs));
+ memset(afs_brs, 0, sizeof(afs_brs));
brsInit = 1;
#if defined (AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
/*
if (afs_cold_shutdown) {
afs_brsDaemons = brsInit = 0;
rxepoch_checked = afs_nbrs = 0;
- memset((char *)afs_brs, 0, sizeof(afs_brs));
- memset((char *)&afs_xbrs, 0, sizeof(afs_lock_t));
+ memset(afs_brs, 0, sizeof(afs_brs));
+ memset(&afs_xbrs, 0, sizeof(afs_lock_t));
afs_brsWaiters = 0;
#ifdef AFS_AIX41_ENV
lock_free(&afs_asyncbuf_lock);
/* Allocate and zero the pointer array to the dcache entries */
afs_indexTable = (struct dcache **)
afs_osi_Alloc(sizeof(struct dcache *) * afiles);
- memset((char *)afs_indexTable, 0, sizeof(struct dcache *) * afiles);
+ memset(afs_indexTable, 0, sizeof(struct dcache *) * afiles);
afs_indexTimes =
(afs_hyper_t *) afs_osi_Alloc(afiles * sizeof(afs_hyper_t));
- memset((char *)afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
+ memset(afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
afs_indexUnique =
(afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_uint32));
- memset((char *)afs_indexUnique, 0, afiles * sizeof(afs_uint32));
+ memset(afs_indexUnique, 0, afiles * sizeof(afs_uint32));
afs_indexFlags = (u_char *) afs_osi_Alloc(afiles * sizeof(u_char));
- memset((char *)afs_indexFlags, 0, afiles * sizeof(char));
+ memset(afs_indexFlags, 0, afiles * sizeof(char));
/* Allocate and thread the struct dcache entries themselves */
tdp = afs_Initial_freeDSList =
(struct dcache *)afs_osi_Alloc(aDentries * sizeof(struct dcache));
- memset((char *)tdp, 0, aDentries * sizeof(struct dcache));
+ memset(tdp, 0, aDentries * sizeof(struct dcache));
#ifdef KERNEL_HAVE_PIN
pin((char *)afs_indexTable, sizeof(struct dcache *) * afiles); /* XXX */
pin((char *)afs_indexTimes, sizeof(afs_hyper_t) * afiles); /* XXX */
}
length = (size ? size : sizeof(struct afs_exporter));
ex = (struct afs_exporter *)afs_osi_Alloc(length);
- memset((char *)ex, 0, length);
+ memset(ex, 0, length);
MObtainWriteLock(&afs_xexp, 308);
for (op = root_exported; op; op = op->exp_next) {
if (!op->exp_next)
cacheInfoModTime = 0;
afs_fsfragsize = 1023;
- memset((char *)&afs_stats_cmperf, 0, sizeof(afs_stats_cmperf));
- memset((char *)&cacheDev, 0, sizeof(struct osi_dev));
+ memset(&afs_stats_cmperf, 0, sizeof(afs_stats_cmperf));
+ memset(&cacheDev, 0, sizeof(struct osi_dev));
osi_dnlc_shutdown();
}
} /*shutdown_cache */
afs_FVIndex = -1;
afs_server = (struct rx_service *)0;
AFS_RWLOCK_INIT(&afs_xconn, "afs_xconn");
- memset((char *)&afs_rootFid, 0, sizeof(struct VenusFid));
+ memset(&afs_rootFid, 0, sizeof(struct VenusFid));
AFS_RWLOCK_INIT(&afs_xuser, "afs_xuser");
AFS_RWLOCK_INIT(&afs_xvolume, "afs_xvolume");
AFS_RWLOCK_INIT(&afs_xserver, "afs_xserver");
}
}
np = (struct nfsclientpag *)afs_osi_Alloc(sizeof(struct nfsclientpag));
- memset((char *)np, 0, sizeof(struct nfsclientpag));
+ memset(np, 0, sizeof(struct nfsclientpag));
/* Copy the necessary afs_exporter fields */
memcpy((char *)np, (char *)afs_nfsexporter, sizeof(struct afs_exporter));
np->next = afs_nfspags[i];
nameCache[i].dirp = nameCache[i].vp = NULL;
} else { /* did get the lock */
ncfreelist = NULL;
- memset((char *)nameCache, 0, sizeof(struct nc) * NCSIZE);
- memset((char *)nameHash, 0, sizeof(struct nc *) * NHSIZE);
+ memset(nameCache, 0, sizeof(struct nc) * NCSIZE);
+ memset(nameHash, 0, sizeof(struct nc *) * NHSIZE);
for (i = 0; i < NCSIZE; i++) {
nameCache[i].next = ncfreelist;
ncfreelist = &nameCache[i];
int i;
Lock_Init(&afs_xdnlc);
- memset((char *)&dnlcstats, 0, sizeof(dnlcstats));
- memset((char *)dnlctracetable, 0, sizeof(dnlctracetable));
+ memset(&dnlcstats, 0, sizeof(dnlcstats));
+ memset(dnlctracetable, 0, sizeof(dnlctracetable));
dnlct = 0;
ObtainWriteLock(&afs_xdnlc, 223);
ncfreelist = NULL;
- memset((char *)nameCache, 0, sizeof(struct nc) * NCSIZE);
- memset((char *)nameHash, 0, sizeof(struct nc *) * NHSIZE);
+ memset(nameCache, 0, sizeof(struct nc) * NCSIZE);
+ memset(nameHash, 0, sizeof(struct nc *) * NHSIZE);
for (i = 0; i < NCSIZE; i++) {
nameCache[i].next = ncfreelist;
ncfreelist = &nameCache[i];
tu->vid = UNDEFVID;
tu->states &= ~UHasTokens;
/* security is not having to say you're sorry */
- memset((char *)&tu->ct, 0, sizeof(struct ClearToken));
+ memset(&tu->ct, 0, sizeof(struct ClearToken));
#ifdef UKERNEL
/* set the expire times to 0, causes
* afs_GCUserData to remove this entry
tu->vid = UNDEFVID;
tu->states &= ~UHasTokens;
/* security is not having to say you're sorry */
- memset((char *)&tu->ct, 0, sizeof(struct ClearToken));
+ memset(&tu->ct, 0, sizeof(struct ClearToken));
tu->refCount++;
ReleaseWriteLock(&afs_xuser);
/* We have to drop the lock over the call to afs_ResetUserConns, since
return EINVAL;
}
- memset((char *)results, 0, sizeof(results));
+ memset(results, 0, sizeof(results));
results[0] = afs_cacheBlocks;
results[1] = afs_blocksUsed;
results[2] = afs_cacheFiles;
{
cred_t *cr;
cr = crdup(get_current_cred());
- memset((char *)cr, 0, sizeof(cred_t));
+ memset(cr, 0, sizeof(cred_t));
#if CELL || CELL_PREPARE
cr->cr_id = -1;
#endif
tu->vid = UNDEFVID;
tu->states &= ~UHasTokens;
/* security is not having to say you're sorry */
- memset((char *)&tu->ct, 0, sizeof(struct ClearToken));
+ memset(&tu->ct, 0, sizeof(struct ClearToken));
tu->refCount++;
ReleaseWriteLock(&afs_xuser);
afs_ResetUserConns(tu);
minj = 0;
do {
- memset((char *)dcList, 0, NCHUNKSATONCE * sizeof(struct dcache *));
+ memset(dcList, 0, NCHUNKSATONCE * sizeof(struct dcache *));
high = 0;
moredata = FALSE;
do {
moredata = FALSE;
- memset((char *)dcList, 0,
+ memset(dcList, 0,
NCHUNKSATONCE * sizeof(struct dcache *));
/* overkill, but it gets the lock in case GetDSlot needs it */
afs_stats_cmperf.fs_UpDown[0].sumOfRecordAges = 0;
afs_stats_cmperf.fs_UpDown[0].ageOfYoungestRecord = 0;
afs_stats_cmperf.fs_UpDown[0].ageOfOldestRecord = 0;
- memset((char *)afs_stats_cmperf.fs_UpDown[0].downIncidents, 0,
+ memset(afs_stats_cmperf.fs_UpDown[0].downIncidents, 0,
AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.fs_UpDown[1].sumOfRecordAges = 0;
afs_stats_cmperf.fs_UpDown[1].ageOfYoungestRecord = 0;
afs_stats_cmperf.fs_UpDown[1].ageOfOldestRecord = 0;
- memset((char *)afs_stats_cmperf.fs_UpDown[1].downIncidents, 0,
+ memset(afs_stats_cmperf.fs_UpDown[1].downIncidents, 0,
AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.vl_UpDown[0].sumOfRecordAges = 0;
afs_stats_cmperf.vl_UpDown[0].ageOfYoungestRecord = 0;
afs_stats_cmperf.vl_UpDown[0].ageOfOldestRecord = 0;
- memset((char *)afs_stats_cmperf.vl_UpDown[0].downIncidents, 0,
+ memset(afs_stats_cmperf.vl_UpDown[0].downIncidents, 0,
AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.vl_UpDown[1].sumOfRecordAges = 0;
afs_stats_cmperf.vl_UpDown[1].ageOfYoungestRecord = 0;
afs_stats_cmperf.vl_UpDown[1].ageOfOldestRecord = 0;
- memset((char *)afs_stats_cmperf.vl_UpDown[1].downIncidents, 0,
+ memset(afs_stats_cmperf.vl_UpDown[1].downIncidents, 0,
AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
/*
if (!newts)
panic("malloc of server struct");
afs_totalServers++;
- memset((char *)newts, 0, sizeof(struct server));
+ memset(newts, 0, sizeof(struct server));
/* Add the server struct to the afs_servers[] hash chain */
srvhash =
if (!newsa)
panic("malloc of srvAddr struct");
afs_totalSrvAddrs++;
- memset((char *)newsa, 0, sizeof(struct srvAddr));
+ memset(newsa, 0, sizeof(struct srvAddr));
/* Add the new srvAddr to the afs_srvAddrs[] hash chain */
newsa->next_bkt = afs_srvAddrs[iphash];
(struct server *)afs_osi_Alloc(sizeof(struct server));
if (!orphts)
panic("malloc of lo server struct");
- memset((char *)orphts, 0, sizeof(struct server));
+ memset(orphts, 0, sizeof(struct server));
afs_totalServers++;
/* Add the orphaned server to the afs_servers[] hash chain.
/*
* First step is to zero everything out.
*/
- memset((char *)(&afs_cmstats), 0, sizeof(struct afs_CMStats));
- memset((char *)(&afs_stats_cmperf), 0, sizeof(struct afs_stats_CMPerf));
- memset((char *)(&afs_stats_cmfullperf), 0,
+ memset((&afs_cmstats), 0, sizeof(struct afs_CMStats));
+ memset((&afs_stats_cmperf), 0, sizeof(struct afs_stats_CMPerf));
+ memset((&afs_stats_cmfullperf), 0,
sizeof(struct afs_stats_CMFullPerf));
/*
#ifndef AFS_NOSTATS
afs_stats_cmfullperf.authent.PAGCreations++;
#endif /* AFS_NOSTATS */
- memset((char *)tu, 0, sizeof(struct unixuser));
+ memset(tu, 0, sizeof(struct unixuser));
tu->next = afs_users[i];
afs_users[i] = tu;
if (RmtUser) {
{
afs_uint32 slot;
slot = tvc->diskSlot;
- memset((char *)tvc, 0, sizeof(struct vcache));
+ memset(tvc, 0, sizeof(struct vcache));
tvc->diskSlot = slot;
}
#else
- memset((char *)tvc, 0, sizeof(struct vcache));
+ memset(tvc, 0, sizeof(struct vcache));
#endif
#else
/* Don't forget to free the gnode space */
tvc->v.v_gnode = gnodepnt =
(struct gnode *)osi_AllocSmallSpace(sizeof(struct gnode));
- memset((char *)gnodepnt, 0, sizeof(struct gnode));
+ memset(gnodepnt, 0, sizeof(struct gnode));
#endif
#ifdef AFS_SGI64_ENV
memset((void *)&(tvc->vc_bhv_desc), 0, sizeof(tvc->vc_bhv_desc));
#endif /* AFS_SGI_ENV */
tvc->dchint = NULL;
osi_dnlc_purgedp(tvc); /* this may be overkill */
- memset((char *)&(tvc->callsort), 0, sizeof(struct afs_q));
+ memset(&(tvc->callsort), 0, sizeof(struct afs_q));
tvc->slocks = NULL;
tvc->f.states &=~ CVInit;
afs_osi_Wakeup(&tvc->f.states);
#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
/* Allocate and thread the struct vcache entries */
tvp = (struct vcache *)afs_osi_Alloc(astatSize * sizeof(struct vcache));
- memset((char *)tvp, 0, sizeof(struct vcache) * astatSize);
+ memset(tvp, 0, sizeof(struct vcache) * astatSize);
Initial_freeVCList = tvp;
freeVCList = &(tvp[0]);
struct fvolume *tf = 0;
tv = afs_GetVolSlot();
- memset((char *)tv, 0, sizeof(struct volume));
+ memset(tv, 0, sizeof(struct volume));
tv->cell = tcell->cellNum;
AFS_RWLOCK_INIT(&tv->lock, "volume lock");
tv->next = afs_volumes[i]; /* thread into list */
ListAddrByAttributes attrs;
afsUUID uuid;
- memset((char *)&attrs, 0, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
attrs.uuid = ve->serverNumber[i];
- memset((char *)&uuid, 0, sizeof(uuid));
- memset((char *)&addrs, 0, sizeof(addrs));
+ memset(&uuid, 0, sizeof(uuid));
+ memset(&addrs, 0, sizeof(addrs));
do {
tconn =
afs_ConnByMHosts(tcell->cellHosts, tcell->vlport,
for (i = 0; i < numFS; i++) {
curr_fsDataP->probeOK = 0;
curr_fsDataP->ovfCount = 0;
- memset((char *)curr_fsDataP->data, 0, numBytes);
+ memset(curr_fsDataP->data, 0, numBytes);
curr_fsDataP++;
}
for (i = 0; i < numCM; i++) {
curr_cmDataP->probeOK = 0;
curr_cmDataP->ovfCount = 0;
- memset((char *)curr_cmDataP->data, 0, numBytes);
+ memset(curr_cmDataP->data, 0, numBytes);
curr_cmDataP++;
}
struct afsconf_dir *configdir;
memset(local_cell, 0, sizeof(local_cell));
- memset((char *)cellconfig, 0, sizeof(*cellconfig));
+ memset(cellconfig, 0, sizeof(*cellconfig));
if (!(configdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
fprintf(stderr,
? "/" : "", inst ? inst : "", realm);
}
- memset((char *)&increds, 0, sizeof(increds));
+ memset(&increds, 0, sizeof(increds));
/* ANL - instance may be ptr to a null string. Pass null then */
if ((r = krb5_build_principal(context, &increds.server,
strlen(realm), realm,
"bnode-manager", &bproc_pid);
if (code)
return code;
- memset((char *)&newaction, 0, sizeof(newaction));
+ memset(&newaction, 0, sizeof(newaction));
newaction.sa_handler = bnode_Int;
code = sigaction(SIGCHLD, &newaction, NULL);
if (code)
struct sigaction intaction, oldaction;
struct cmd_syndesc *cptr;
- memset((char *)&intaction, 0, sizeof(intaction));
+ memset(&intaction, 0, sizeof(intaction));
intaction.sa_handler = quitFms;
sigaction(SIGINT, &intaction, &oldaction);
des_key_sched(cblockptr_to_cblock(key), key_sked);
des_cbc_cksum(charptr_to_cblockptr(in_str), key, length, key_sked, key);
/* erase key_sked */
- memset((char *)key_sked, 0, sizeof(key_sked));
+ memset(key_sked, 0, sizeof(key_sked));
/* now fix up key parity again */
des_fixup_key_parity(cblockptr_to_cblock(key));
struct sockaddr_in to;
int timeAvail, timePerIter, numIters;
- memset((char *)&to, 0, sizeof(to));
+ memset(&to, 0, sizeof(to));
if ((f = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
if (krb_debug)
fprintf(stderr, "%s: Can't open socket\n", prog);
int releasecount = 0;
struct volser_status volstatus;
- memset((char *)remembertime, 0, sizeof(remembertime));
- memset((char *)&results, 0, sizeof(results));
+ memset(remembertime, 0, sizeof(remembertime));
+ memset(&results, 0, sizeof(results));
tst =
ubik_VL_SetLock(cellHandle->vos, 0, afromvol, RWVOL,
{
PROCESS lp;
assert(lp = (PROCESS) malloc(sizeof(*lp)));
- memset((char *)lp, 0, sizeof(*lp));
+ memset(lp, 0, sizeof(*lp));
if (!name) {
char temp[100];
static procnum;
}
#if HAVE_SIGACTION && defined(SA_SIGINFO)
- memset((char *)&action, 0, sizeof(action));
+ memset(&action, 0, sizeof(action));
action.sa_sigaction = AlarmHandler;
action.sa_flags = SA_SIGINFO;
|| (setitimer(ITIMER_REAL, &itv, NULL) == -1))
return (LWP_ESYSTEM);
#else
- memset((char *)&vec, 0, sizeof(vec));
+ memset(&vec, 0, sizeof(vec));
vec.sv_handler = AlarmHandler;
vec.sv_mask = vec.sv_onstack = 0;
itv.it_value.tv_sec = itv.it_value.tv_usec = 0;
#if HAVE_SIGACTION && defined(SA_SIGINFO)
- memset((char *)&action, 0, sizeof(action));
+ memset(&action, 0, sizeof(action));
action.sa_handler = SIG_DFL;
if ((setitimer(ITIMER_REAL, &itv, NULL) == -1)
return (LWP_ESYSTEM);
#else
- memset((char *)&vec, 0, sizeof(vec));
+ memset(&vec, 0, sizeof(vec));
vec.sv_handler = SIG_DFL;
vec.sv_mask = vec.sv_onstack = 0;
IOMGR_AllocFDSet(void)
{
fd_set *tmp = (fd_set *) malloc(sizeof(fd_set));
- memset((char *)tmp, 0, sizeof(fd_set));
+ memset(tmp, 0, sizeof(fd_set));
return tmp;
}
zeromap(struct idused *idmap)
{
while (idmap) {
- memset((char *)idmap->idcount, 0, sizeof idmap->idcount);
+ memset(idmap->idcount, 0, sizeof idmap->idcount);
idmap = idmap->idnext;
}
}
perror("idmap");
exit(1);
}
- memset((char *)idmap, 0, sizeof idmap);
+ memset(idmap, 0, sizeof idmap);
idmap->idstart = id & ~(IDCOUNT - 1);
idmap->idnext = *idmapp;
*idmapp = idmap;
return 0;
}
map->m_page = page;
- memset((char *) map->m_data, 0, sizeof map->m_data);
+ memset( map->m_data, 0, sizeof map->m_data);
if (NEGMAP(parm)) {
int i;
for (i = 0; i < MDATA; ++i)
free_map((struct map *)result);
return 0;
}
- memset((char *) map->m_data, 0, sizeof map->m_data);
+ memset( map->m_data, 0, sizeof map->m_data);
map->m_page = page;
map->m_next = 0;
*mp = map;
return (1);
}
if (status < len)
- memset((char *)buf + status, 0, len - status);
+ memset(buf + status, 0, len - status);
return (0);
}
rxi_nCalls = 0;
rx_connDeadTime = 12;
rx_tranquil = 0; /* reset flag */
- memset((char *)&rx_stats, 0, sizeof(struct rx_statistics));
+ memset(&rx_stats, 0, sizeof(struct rx_statistics));
htable = (char *)
osi_Alloc(rx_hashTableSize * sizeof(struct rx_connection *));
PIN(htable, rx_hashTableSize * sizeof(struct rx_connection *)); /* XXXXX */
osi_Assert(p);
PIN(p, getme); /* XXXXX */
- memset((char *)p, 0, getme);
+ memset(p, 0, getme);
RX_TS_INFO_GET(rx_ts_info);
RX_TS_FPQ_LOCAL_ALLOC(rx_ts_info,apackets);
osi_Assert(p);
PIN(p, getme); /* XXXXX */
- memset((char *)p, 0, getme);
+ memset(p, 0, getme);
NETPRI;
MUTEX_ENTER(&rx_freePktQ_lock);
p = (struct rx_packet *)osi_Alloc(getme);
PIN(p, getme); /* XXXXX */
- memset((char *)p, 0, getme);
+ memset(p, 0, getme);
RX_TS_INFO_GET(rx_ts_info);
RX_TS_FPQ_LOCAL_ALLOC(rx_ts_info,apackets);
osi_Assert(apackets > 0);
}
} while(p == NULL);
- memset((char *)p, 0, getme);
+ memset(p, 0, getme);
#ifdef RX_ENABLE_TSFPQ
RX_TS_INFO_GET(rx_ts_info);
savelen = p->wirevec[p->niovecs - 1].iov_len;
p->wirevec[p->niovecs - 1].iov_len += RX_EXTRABUFFERSIZE;
- memset((char *)&msg, 0, sizeof(msg));
+ memset(&msg, 0, sizeof(msg));
msg.msg_name = (char *)&from;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = p->wirevec;
struct rx_debugStats tstat;
/* get basic stats */
- memset((char *)&tstat, 0, sizeof(tstat)); /* make sure spares are zero */
+ memset(&tstat, 0, sizeof(tstat)); /* make sure spares are zero */
tstat.version = RX_DEBUGI_VERSION;
#ifndef RX_ENABLE_LOCKS
tstat.waitingForPackets = rx_waitingForPackets;
if (tl > 0)
return ap;
- memset((char *)&tconn, 0, sizeof(tconn)); /* make sure spares are zero */
+ memset(&tconn, 0, sizeof(tconn)); /* make sure spares are zero */
/* get N'th (maybe) "interesting" connection info */
for (i = 0; i < rx_hashTableSize; i++) {
#if !defined(KERNEL)
if (tl > 0)
return ap;
- memset((char *)&tpeer, 0, sizeof(tpeer));
+ memset(&tpeer, 0, sizeof(tpeer));
for (i = 0; i < rx_hashTableSize; i++) {
#if !defined(KERNEL)
/* the time complexity of the algorithm used here
{
afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base); /* MTUXXX */
- memset((char *)buf, 0, RX_HEADER_SIZE);
+ memset(buf, 0, RX_HEADER_SIZE);
*buf++ = htonl(p->header.epoch);
*buf++ = htonl(p->header.cid);
*buf++ = htonl(p->header.callNumber);
token tok;
defp = ALLOC(definition);
- memset((char *)defp, 0, sizeof(definition));
+ memset(defp, 0, sizeof(definition));
get_token(&tok);
switch (tok.kind) {
case TOK_STRUCT:
do {
get_token(tokp);
Proc_list = ALLOC(proc1_list);
- memset((char *)Proc_list, 0, sizeof(proc1_list));
+ memset(Proc_list, 0, sizeof(proc1_list));
Proc_list->pl.param_flag = 0;
switch (tokp->kind) {
case TOK_IN:
*Proc_listp = Proc_list;
Proc_listp = &Proc_list->next;
decls = ALLOC(decl_list);
- memset((char *)decls, 0, sizeof(decl_list));
+ memset(decls, 0, sizeof(decl_list));
if (tokp->kind != TOK_RPAREN)
decls->decl = dec;
*tailp = decls;
des_cbc_encrypt(in, out, insz, s, &ivec, 0);
memcpy(cksum, (char *)out + CONFOUNDERSZ, cksumsz);
- memset((char *)out + CONFOUNDERSZ, 0, cksumsz);
+ memset(out + CONFOUNDERSZ, 0, cksumsz);
if (cksum_func)
ret = (*cksum_func) (out, insz, cksum, cksumsz, key);
struct hostent *hp;
fd_set reads;
- memset((char *)someSignals, 0, sizeof(someSignals));
+ memset(someSignals, 0, sizeof(someSignals));
someSignals[0] = 1 << (SIGURG - 1);
sigBlock = *((sigset_t *) someSignals);
static krb5_principal client_principal = 0;
char *str;
- memset((char *)&increds, 0, sizeof(increds));
+ memset(&increds, 0, sizeof(increds));
/* instance may be ptr to a null string. Pass null then */
if ((r = krb5_build_principal(context, &increds.server,
strlen(realm), realm,
struct afsconf_dir *configdir;
memset(local_cell, 0, sizeof(local_cell));
- memset((char *)cellconfig, 0, sizeof(*cellconfig));
+ memset(cellconfig, 0, sizeof(*cellconfig));
if (!(configdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
return AFSCONF_NODB;
int j;
afs_int32 *Tmpafs_int32;
- memset((char *) Status, 0, sizeof(struct AFSFetchStatus));
+ memset( Status, 0, sizeof(struct AFSFetchStatus));
memset(buf, 0, sizeof(buf));
status.in_size = 0;
status.out_size = sizeof(buf);
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
lip = (struct logInfo *)malloc(sizeof(struct logInfo));
- memset((char *)lip, 0, sizeof(*lip));
+ memset(lip, 0, sizeof(*lip));
lip->nextp = allInfo;
allInfo = lip;
lip->name = (char *)malloc(strlen(tname) + 1);
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
lip = (struct logInfo *)malloc(sizeof(struct logInfo));
- memset((char *)lip, 0, sizeof(*lip));
+ memset(lip, 0, sizeof(*lip));
lip->nextp = allInfo;
allInfo = lip;
lip->name = (char *)malloc(strlen(tname) + 1);
exit(1);
}
}
- memset((char *)setInfo, 0, infoSize);
+ memset(setInfo, 0, infoSize);
return setInfo;
}
}
}
- memset((char *)logInfo, 0, infoSize);
+ memset(logInfo, 0, infoSize);
return logInfo;
}
int chainCount[NSERVERS];
if (pnt) {
- memset((char *)chainCount, 0, sizeof(chainCount));
+ memset(chainCount, 0, sizeof(chainCount));
printf("\n\nPrinting 'afs_servers' structures...\n");
}
findsym("afs_servers", &symoff);
/* Verify against afs_totalServers. */
if (pnt) {
- memset((char *)chainCount, 0, sizeof(chainCount));
+ memset(chainCount, 0, sizeof(chainCount));
if (findsym("afs_totalServers", &symoff)) {
kread(kmem, symoff, (char *)&afs_totalServers, sizeof(afs_int32));
if (afs_totalServers != nServers) {
register struct dinode *dp;
struct inodesc curino;
- memset((char *)&curino, 0, sizeof(struct inodesc));
+ memset(&curino, 0, sizeof(struct inodesc));
if (statemap[inumber] != DSTATE)
errexit("BAD INODE %d TO DESCEND", statemap[inumber]);
#if defined(ACLS) && defined(AFS_HPUX_ENV)
char tempname[BUFSIZ];
extern int pass4check();
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
dp = ginode(orphan);
lostdir = (dp->di_mode & IFMT) == IFDIR;
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
if (parent < ROOTINO || parent >= maxino || ino < ROOTINO
|| ino >= maxino)
return (0);
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
idesc.id_func = mkentry;
idesc.id_number = parent;
extern int pass4check();
struct dinode *dp;
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass4check;
idesc.id_number = ino;
/*
* Find all allocated blocks.
*/
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1check;
inumber = 0;
struct inodesc idesc;
ino_t inumber;
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1bcheck;
duphead = duplist;
register struct dinode *dp;
struct inodesc rootdesc;
- memset((char *)&rootdesc, 0, sizeof(struct inodesc));
+ memset(&rootdesc, 0, sizeof(struct inodesc));
rootdesc.id_type = ADDR;
rootdesc.id_func = pass2check;
rootdesc.id_number = ROOTINO;
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
dirp = (struct direct *)((char *)(dirp) + entrysize);
- memset((char *)dirp, 0, n);
+ memset(dirp, 0, n);
dirp->d_reclen = n;
if (reply("FIX") == 1)
ret |= ALTERED;
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
dirp = (struct direct *)((char *)(dirp) + n);
- memset((char *)dirp, 0, n);
+ memset(dirp, 0, n);
dirp->d_reclen = n;
}
if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
ino_t inumber, orphan;
int loopcnt;
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
for (inumber = ROOTINO; inumber <= lastino; inumber++) {
#if defined(ACLS) && defined(AFS_HPUX_ENV)
#endif /* ACLS */
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass4check;
for (inumber = ROOTINO; inumber <= lastino; inumber++) {
struct cg *ocg = (struct cg *)buf;
#endif /* AFS_NEWCG_ENV */
- memset((char *)newcg, 0, (int)fs->fs_cgsize);
+ memset(newcg, 0, (int)fs->fs_cgsize);
newcg->cg_niblk = fs->fs_ipg;
#ifdef AFS_NEWCG_ENV
postype = (int)fs->fs_postblformat;
#endif /* AFS_NEWCG_ENV */
}
- memset((char *)&idesc[0], 0, sizeof idesc);
+ memset(&idesc[0], 0, sizeof idesc);
for (i = 0; i < 3; i++)
idesc[i].id_type = ADDR;
- memset((char *)&cstotal, 0, sizeof(struct csum));
+ memset(&cstotal, 0, sizeof(struct csum));
(void)time(&now);
#ifdef notdef
/* this is the original from UCB/McKusick, but it is clearly wrong. It is
newcg->cg_irotor = cg->cg_irotor;
else
newcg->cg_irotor = 0;
- memset((char *)&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum);
+ memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum);
#ifdef AFS_NEWCG_ENV
- memset((char *)&cg_blktot(newcg)[0], 0, sumsize + mapsize);
+ memset(&cg_blktot(newcg)[0], 0, sumsize + mapsize);
#else /* AFS_NEWCG_ENV */
- memset((char *)newcg->cg_btot, 0, sizeof(newcg->cg_btot));
- memset((char *)newcg->cg_b, 0, sizeof(newcg->cg_b));
- memset((char *)newcg->cg_iused, 0, sizeof(newcg->cg_iused));
- memset((char *)newcg->cg_free, 0, howmany(fs->fs_fpg, NBBY));
+ memset(newcg->cg_btot, 0, sizeof(newcg->cg_btot));
+ memset(newcg->cg_b, 0, sizeof(newcg->cg_b));
+ memset(newcg->cg_iused, 0, sizeof(newcg->cg_iused));
+ memset(newcg->cg_free, 0, howmany(fs->fs_fpg, NBBY));
#endif /* AFS_NEWCG_ENV */
#ifdef AFS_NEWCG_ENV
if (fs->fs_postblformat == FS_42POSTBLFMT)
if (memcmp
((char *)&sblock.fs_blank[0], (char *)&altsblock.fs_blank[0],
MAXCSBUFS * sizeof(int))) {
- memset((char *)sblock.fs_blank, 0, sizeof(sblock.fs_blank));
+ memset(sblock.fs_blank, 0, sizeof(sblock.fs_blank));
} else {
#endif /* __alpha */
badsb(listerr,
strcpy(namebuf, "?");
return;
}
- memset((char *)&idesc, 0, sizeof(struct inodesc));
+ memset(&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
cp = &namebuf[BUFSIZ - 1];
*cp = '\0';
printf("usage: pxclient <serverHost>\n");
exit(1);
}
- memset((char *)&host, 0, sizeof(struct sockaddr_in));
+ memset(&host, 0, sizeof(struct sockaddr_in));
host.sin_family = AF_INET;
host.sin_addr.s_addr = inet_addr(av[0]);
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
entry = CEFree;
CEFree = entry->next;
CEs++;
- memset((char *)entry, 0, CLIENT_TO_ZERO(entry));
+ memset(entry, 0, CLIENT_TO_ZERO(entry));
return (entry);
} /*GetCE */
entry = HTFree;
HTFree = entry->next;
HTs++;
- memset((char *)entry, 0, HOST_TO_ZERO(entry));
+ memset(entry, 0, HOST_TO_ZERO(entry));
return (entry);
} /*GetHT */
{
afs_uint32 now = FT_ApproxTime();
- memset((char *)&zerofid, 0, sizeof(zerofid));
+ memset(&zerofid, 0, sizeof(zerofid));
/*
* Send a probe to the workstation if it hasn't been heard from in
* 15 minutes
FidZap(DirHandle * file)
{
IH_RELEASE(file->dirh_handle);
- memset((char *)file, 0, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
void
FidZero(DirHandle * file)
{
- memset((char *)file, 0, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
int
/*
* Zero all xstat-related structures.
*/
- memset((char *)(&afs_perfstats), 0, sizeof(struct afs_PerfStats));
+ memset((&afs_perfstats), 0, sizeof(struct afs_PerfStats));
#if FS_STATS_DETAILED
- memset((char *)(&afs_FullPerfStats), 0,
+ memset((&afs_FullPerfStats), 0,
sizeof(struct fs_stats_FullPerfStats));
/*
struct vlentry_2 vl;
struct vlentry_3 *xnvlentry = (struct vlentry_3 *)vlentryp;
- memset((char *)&vl, 0, sizeof(struct vlentry_2));
+ memset(&vl, 0, sizeof(struct vlentry_2));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
- (fromvers ==
1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
- memset((char *)&vl, 0, sizeof(struct vlentry_1));
+ memset(&vl, 0, sizeof(struct vlentry_1));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
record = (struct er *)malloc(maxentries * sizeof(struct er));
- memset((char *)record, 0, (maxentries * sizeof(struct er)));
- memset((char *)serveraddrs, 0, sizeof(serveraddrs));
+ memset(record, 0, (maxentries * sizeof(struct er)));
+ memset(serveraddrs, 0, sizeof(serveraddrs));
/* Will fill in the record array of entries it found */
ReadAllEntries(&header);
if (!ex_addr[base])
ERROR_EXIT(VL_NOMEM);
}
- memset((char *)ex_addr[base], 0, VL_ADDREXTBLK_SIZE);
+ memset(ex_addr[base], 0, VL_ADDREXTBLK_SIZE);
/* Write the full extension block at end of vldb */
ex_addr[base]->ex_flags = htonl(VLCONTBLOCK);
CREATE_ALWAYS, FILE_ATTRIBUTE_HIDDEN, NULL);
assert(dp->lock_fd != INVALID_FD);
- memset((char *)&lap, 0, sizeof(lap));
+ memset(&lap, 0, sizeof(lap));
rc = LockFileEx((HANDLE) dp->lock_fd, LOCKFILE_EXCLUSIVE_LOCK, 0, 1,
0, &lap);
assert(rc);
if (!dp)
return; /* no partition, will fail later */
- memset((char *)&lap, 0, sizeof(lap));
+ memset(&lap, 0, sizeof(lap));
UnlockFileEx((HANDLE) dp->lock_fd, 0, 1, 0, &lap);
CloseHandle((HANDLE) dp->lock_fd);
VolumeHeaderToDisk(VolumeDiskHeader_t * dh, VolumeHeader_t * h)
{
- memset((char *)dh, 0, sizeof(VolumeDiskHeader_t));
+ memset(dh, 0, sizeof(VolumeDiskHeader_t));
dh->stamp = h->stamp;
dh->id = h->id;
dh->parent = h->parent;
void
DiskToVolumeHeader(VolumeHeader_t * h, VolumeDiskHeader_t * dh)
{
- memset((char *)h, 0, sizeof(VolumeHeader_t));
+ memset(h, 0, sizeof(VolumeHeader_t));
h->stamp = dh->stamp;
h->id = dh->id;
h->parent = dh->parent;
* area and mark it as initialized.
*/
if (!(V_stat_initialized(vp))) {
- memset((char *)(V_stat_area(vp)), 0, VOL_STATS_BYTES);
+ memset((V_stat_area(vp)), 0, VOL_STATS_BYTES);
V_stat_initialized(vp) = 1;
}
#endif /* OPENAFS_VOL_STATS */
* All we need to do is bzero the entire VOL_STATS_BYTES of
* the detailed volume statistics area.
*/
- memset((char *)(V_stat_area(vp)), 0, VOL_STATS_BYTES);
+ memset((V_stat_area(vp)), 0, VOL_STATS_BYTES);
#endif /* OPENAFS_VOL_STATS */
}
FDH_CLOSE(fdP);
return -1;
}
- memset((char *)Buf, 0, nVnodes * sizeof(afs_int32));
+ memset(Buf, 0, nVnodes * sizeof(afs_int32));
STREAM_SEEK(afile, offset = vcp->diskSize, 0);
while (1) {
code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
* Copy out the stat fields in a single operation.
*/
if ((now - hdr->dayUseDate) > OneDay) {
- memset((char *)&(handle->volinfo_ptr.ext->stat_reads[0]),
+ memset(&(handle->volinfo_ptr.ext->stat_reads[0]),
0, numStatBytes);
} else {
memcpy((char *)&(handle->volinfo_ptr.ext->stat_reads[0]),
static void
qInit(struct tqHead *ahead)
{
- memset((char *)ahead, 0, sizeof(struct tqHead));
+ memset(ahead, 0, sizeof(struct tqHead));
return;
}
struct volser_status volstatus;
char hoststr[16];
- memset((char *)remembertime, 0, sizeof(remembertime));
- memset((char *)&results, 0, sizeof(results));
+ memset(remembertime, 0, sizeof(remembertime));
+ memset(&results, 0, sizeof(results));
vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
if (vcode != VL_RERELEASE)
projects / packages / o / openafs.git / commitdiff