ufs_brelse(struct usr_vnode *vp, struct usr_buf *bp)
{
usr_assert(0);
+ return 0;
}
/*
iodone(struct usr_buf *bp)
{
usr_assert(0);
+ return 0;
}
struct usr_file *
getf(int fd)
{
usr_assert(0);
+ return 0;
}
/*
usr_flock(void)
{
usr_assert(0);
+ return 0;
}
/*
usr_ioctl(void)
{
usr_assert(0);
+ return 0;
}
/*
afs_syscall_icreate(void)
{
usr_assert(0);
+ return 0;
}
int
afs_syscall_iincdec(void)
{
usr_assert(0);
+ return 0;
}
int
afs_syscall_iopen(void)
{
usr_assert(0);
+ return 0;
}
int
afs_syscall_ireadwrite(void)
{
usr_assert(0);
+ return 0;
}
/*
vno_close(void)
{
usr_assert(0);
+ return 0;
}
int
vno_ioctl(void)
{
usr_assert(0);
+ return 0;
}
int
vno_rw(void)
{
usr_assert(0);
+ return 0;
}
int
vno_select(void)
{
usr_assert(0);
+ return 0;
}
/*
if (credp->cr_ref == 0) {
afs_osi_Free((char *)credp, sizeof(struct usr_ucred));
}
+ return 0;
}
int
usr_crhold(struct usr_ucred *credp)
{
credp->cr_ref++;
+ return 0;
}
void
waitp = waitp->next;
}
usr_mutex_unlock(&osi_waitq_lock);
+ return 0;
}
int
waitp = waitp->timedNext;
}
usr_mutex_unlock(&osi_waitq_lock);
+ return 0;
}
/*
sysArgsP->param2, sysArgsP->param3, sysArgsP->param4);
afs_osi_Free(argp, -1);
+ return 0;
}
fork_syscall(syscall, afscall, param1, param2, param3, param4)
usr_thread_create(&tid, syscallThread, sysArgsP);
usr_thread_detach(tid);
+ return 0;
}
call_syscall(syscall, afscall, param1, param2, param3, param4)
struct usr_vnode *linkVp;
char *tmpPath;
char *pathP;
- char *nextPathP;
+ char *nextPathP = NULL;
AFS_ASSERT_GLOCK();
afs_xsetgroups()
{
usr_assert(0);
+ return 0;
}
static int
#endif
#endif
+
+#ifdef KERNEL
+/* it does not compile outside kernel */
struct buffer {
afs_int32 fid; /* is adc->index, the cache file number */
afs_inode_t inode; /* is adc->f.inode, the inode number of the cac\
afs_int32 chunkBytes; /* Num bytes in this chunk */
char states; /* Has this chunk been modified? */
};
+#endif
/* magic numbers to specify the cache type */
DECL_PIOCTL(PSetSysName)
{
char *cp, *cp2 = NULL, inname[MAXSYSNAME], outname[MAXSYSNAME];
- int setsysname, foundname = 0;
+ afs_int32 setsysname;
+ int foundname = 0;
register struct afs_exporter *exporter;
register struct unixuser *au;
register afs_int32 pag, error;
#endif
}
memset(inname, 0, MAXSYSNAME);
- memcpy((char *)&setsysname, ain, sizeof(afs_int32));
+ memcpy(&setsysname, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
if (setsysname & 0x8000) {
allpags = 1;
sa->sa_iprank = afs_min(sa->sa_iprank, MED);
}
}
+ return 0;
}
#else /* AFS_USERSPACE_IP_ADDR */
#if (! defined(AFS_SUN5_ENV)) && !defined(AFS_DARWIN60_ENV) && defined(USEIFADDR)
}
afsmon_Exit(0);
+ return 0; /* not reached */
}
rx_SetMinProcs(tservice, 2);
rx_SetMaxProcs(tservice, 4);
rx_StartServer(1); /* donate this process */
+ return 0;
}
void
cmd_AddParm(cptr, "-tape", CMD_SINGLE, CMD_REQUIRED, "tape special file");
cmd_Dispatch(argc, argv);
+ return 0;
}
static int
/* printIfStatus
* print out an interface status node as received from butc
*/
-
+
+void
printIfStatus(statusPtr)
struct tciStatusS *statusPtr;
{
#include <netinet/in.h>
#include <netdb.h>
#endif
+#include <stdio.h>
+#include <string.h>
#include <dirent.h>
#include <afs/afsutil.h>
#include <afs/budb.h>
extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cf,
char *name);
+static FreeVolumeEntryList();
+static FreeVolumeEntry();
/* Code to maintain dump schedule and volume set abstractions.
* A volume set looks like this:
* free the list of volumes used for dumps
*/
+void
freeDumpTaskVolumeList(vdptr)
struct bc_volumeDump *vdptr;
{
*/
#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
#include <afsconfig.h>
#include <afs/param.h>
extern struct udbHandleS udbHandle;
extern char *whoami;
+static ListDumpSchedule();
/* ------------------------------------
* command level routines
static char expbuf[ESIZE], *braslist[NBRA], *braelist[NBRA];
static char circf;
+static int advance();
+static int backref();
+static int cclass();
+
/*
* compile the regular expression argument into a dfa
*/
return (atol(sptr));
}
+void
viceName(value)
long value;
{
* These routines are common the backup coordinator and tape coordinator
*/
+void
initStatus()
{
dlqInit(&statusHead);
/* lock managment */
+void
lock_Status()
{
ObtainWriteLock(&statusQueueLock);
}
+void
unlock_Status()
{
ReleaseWriteLock(&statusQueueLock);
}
+void
lock_cmdLine()
{
ObtainWriteLock(&cmdLineLock);
}
+void
unlock_cmdLine()
{
ReleaseWriteLock(&cmdLineLock);
return (ptr);
}
+void
deleteStatusNode(ptr)
statusP ptr;
{
extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cf, char *name);
extern void FreeVolumeSet(struct bc_volumeSet *avset);
+static ListVolSet();
/* ------------------------------------
* command level routines
* no return value
*/
+void
haveWritten(nbytes)
afs_int32 nbytes;
{
* done flag.
*/
+void
doneWriting(error)
afs_int32 error;
{
}
/* debug support */
-
+void
saveTextToFile(ut, tbPtr)
struct ubik_trans *ut;
struct textBlock *tbPtr;
* initialize all the supported commands and their arguments
*/
+void
initializeArgHandler()
{
struct cmd_syndesc *cptr;
return (code);
}
-
+void
consistencyCheckDb()
{
/* do consistency checks on structure sizes */
* print the hash table structure, i.e. the header structure.
*/
+void
printHashTable(fid, htptr)
FILE *fid;
struct hashTable *htptr;
* currently used for debug only
*/
+void
volFragment_ntoh(netVfPtr, hostVfPtr)
struct volFragment *netVfPtr, *hostVfPtr;
{
hostVfPtr->sequence = ntohs(netVfPtr->sequence);
}
+void
volInfo_ntoh(netViPtr, hostViPtr)
struct volInfo *netViPtr, *hostViPtr;
{
hostViPtr->nFrags = ntohl(netViPtr->nFrags);
}
+void
tape_ntoh(netTapePtr, hostTapePtr)
struct tape *netTapePtr, *hostTapePtr;
{
hostTapePtr->useCount = ntohl(netTapePtr->useCount);
}
+void
dump_ntoh(netDumpPtr, hostDumpPtr)
struct dump *netDumpPtr, *hostDumpPtr;
{
principal_ntoh(&netDumpPtr->dumper, &hostDumpPtr->dumper);
}
+void
DbHeader_ntoh(netptr, hostptr)
struct DbHeader *netptr, *hostptr;
{
hostptr->lastTapeId = ntohl(netptr->lastTapeId);
}
+void
dumpEntry_ntoh(netptr, hostptr)
struct budb_dumpEntry *netptr, *hostptr;
{
return 0;
}
+void
structDumpHeader_hton(hostPtr, netPtr)
struct structDumpHeader *hostPtr, *netPtr;
{
netPtr->size = htonl(hostPtr->size);
}
+void
structDumpHeader_ntoh(netPtr, hostPtr)
struct structDumpHeader *hostPtr, *netPtr;
{
hostPtr->size = ntohl(netPtr->size);
}
+void
tapeEntry_ntoh(netptr, hostptr)
struct budb_tapeEntry *netptr, *hostptr;
{
return 0;
}
+void
textBlock_hton(hostptr, netptr)
struct textBlock *hostptr, *netptr;
{
netptr->newTextAddr = htonl(hostptr->newTextAddr);
}
+void
textBlock_ntoh(netptr, hostptr)
struct textBlock *netptr, *hostptr;
{
hostptr->newTextAddr = ntohl(netptr->newTextAddr);
}
+void
textLock_hton(hostptr, netptr)
db_lockP hostptr, netptr;
{
netptr->lockHost = htonl(hostptr->lockHost);
}
+void
textLock_ntoh(netptr, hostptr)
db_lockP netptr, hostptr;
{
hostptr->lockHost = ntohl(netptr->lockHost);
}
+void
volumeEntry_ntoh(netptr, hostptr)
struct budb_volumeEntry *netptr, *hostptr;
{
* -------------------------------------
*/
-
+void
copy_ktcPrincipal_to_budbPrincipal(ktcPtr, budbPtr)
struct ktc_principal *ktcPtr;
struct budb_principal *budbPtr;
tapesetPtr->a = 1;
tapesetPtr->b = 1;
tapesetPtr->maxTapes = 0;
+ return 0;
}
if (message) {
printf("Updating database - done\n");
}
+ return 0;
}
#define MAXVOLUMESTOADD 100
* Regardless of error, the closecallout routine will be called
* (unless a tape is not mounted in the first place).
*/
+void
unmountTape(taskId, tapeInfoPtr)
afs_int32 taskId;
struct butm_tapeInfo *tapeInfoPtr;
/* this is just scaffolding, creates new tape label with name <tapeName> */
+void
GetNewLabel(tapeInfoPtr, pName, AFSName, tapeLabel)
struct butm_tapeInfo *tapeInfoPtr;
char *pName, *AFSName;
* print out the tape label.
*/
+void
PrintTapeLabel(labelptr)
struct butm_tapeLabel *labelptr;
{
return 0;
}
+void
printLabel(tapeLabelPtr)
struct tapeLabel *tapeLabelPtr;
{
}
}
+void
printHeader(headerPtr, isvolheader)
struct volumeHeader *headerPtr;
afs_int32 *isvolheader;
extern struct tapeConfig globalTapeConfig;
extern struct deviceSyncNode *deviceLatch;
+static readDump();
+
/* PrintDumpLabel
* print out the tape (dump) label.
*/
#include "error_macros.h"
#include "butc_xbsa.h"
+static CopyDumpDesc();
+static CopyRestoreDesc();
+static CopyTapeSetDesc();
+
+
int
callPermitted(struct rx_call *call)
{
PROCESS pid;
#endif
struct labelTapeIf *ptr;
- statusP statusPtr;
+ statusP statusPtr = NULL;
afs_int32 code;
extern int Labeller();
#else
PROCESS pid;
#endif
- statusP statusPtr;
+ statusP statusPtr = NULL;
afs_int32 code = 0;
struct saveDbIf *ptr;
extern int dump_namecheck;
extern int autoQuery;
+static void initTapeBuffering();
+static writeDbDump();
+static restoreDbEntries();
+
/* CreateDBDump
* create a dump entry for a saved database
*/
}
static afs_int32 nbytes = 0; /* # bytes left in buffer */
-static
+static void
initTapeBuffering()
{
nbytes = 0;
* dataSize - bytes used on the tape
*/
+void
incSize(info, dataSize)
struct butm_tapeInfo *info;
afs_uint32 dataSize;
* dataSize - bytes used on the tape
*/
+void
incPosition(info, fid, dataSize)
struct butm_tapeInfo *info;
usd_handle_t fid;
if (aframe->messageLine)
free(aframe->messageLine);
aframe->messageLine = gtx_CopyString(amsgLine);
+ return 0;
}
/* Called by input processor to try to clear the dude */
keymap_Delete(tmap);
gtx_InputServer(win);
+ return 0;
}
tframe->flags &= ~GTXFRAME_RECURSIVEEND;
WOP_DISPLAY(awin); /* eventually calls gtxframe_Display */
}
+ return 0;
}
struct gwin *
* the window empty.
*/
if (objects_debug)
- fprintf(stderr, "[%s:%s] Scrolling text object at 0x%x %d lines %s\n",
+ fprintf(stderr, "[%s:%s] Scrolling text object %d lines %s\n",
mn, rn, nlines,
(direction == GATOR_TEXT_SCROLL_UP) ? "UP" : "DOWN");
if (objects_debug) {
fprintf(stderr,
"[%s:%s] Writing %d chars to text object at 0x%x (highlight=%d, skip=%d: '",
- rn, numChars, onp, highlight, skip);
+ mn, rn, numChars, onp, highlight, skip);
for (i = 0; i < numChars; i++)
fprintf(stderr, "%c", strToWrite + i);
fprintf(stderr, "\n");
static afs_int32 maxKeyLifetime;
static int dbfixup = 0;
+void
init_kadatabase(initFlags)
int initFlags; /* same as init_kaprocs (see which) */
{
main(void)
{
printf("kdb not supported\n");
+ return 1;
}
#endif
argv[1] = NULL;
argv[0] = dirpath;
execv(dirpath, argv);
+ return 0;
} else {
using_child = pid; /* save it for later */
childin = fdopen(pipe1[1], "w");
fflush(stdout);
}
}
+ return rc;
}
return;
}
-static
+static void
SocketListener()
{
fd_set rfds;
}
/* ntohEntry - convert back to host-order */
+void
ntohEntry(struct kaentry *entryp)
{
entryp->flags = ntohl(entryp->flags);
afs_com_err(whoami, errno, "reading db got %d bytes", code);
exit(3);
}
+ return 0;
}
#include "AFS_component_version_number.c"
afs_status_t clientSt = 0;
char *clientCellName = NULL;
short cmInstalled = 0;
- unsigned cmVersion;
+ unsigned cmVersion = 0;
/* validate parameters */
{
int rc = 1;
afs_status_t tst = 0;
- int aCount;
- afs_int32 *aList;
+ int aCount = 0;
+ afs_int32 *aList = NULL;
#ifdef AFS_NT40_ENV
/* Note: gethostbyname() allocs hostent on a per-thread basis */
struct rx_debugConn conn;
afs_uint32 supportedStats;
afs_uint32 supportedValues;
- int allconns;
+ int allconns = 1;
int i;
ParseArgs(argc, argv, &srvrName, &srvrPort);
*list = newCellName;
}
afsconf_Close(conf);
+ return 0;
}
/*
fprintf(stderr, "unlog: Warning - no tokens held for cell %s\n",
cellList[index]);
}
+ return 0;
}
lwp_cpptr = runnable[i].head;
returnto(&lwp_cpptr->context);
+
+ return 0; /* not reachable */
}
/* Complain of a stack overflow to stderr without using stdio. */
fprintf(stderr, "%s (%d).\n", pr_ErrorMsg(code), code);
}
}
+ return 0;
}
#else /* KERNEL */
# include <sys/types.h>
# include <stdio.h>
+# include <string.h>
#ifdef AFS_PTHREAD_ENV
# include "rx_pthread.h"
#else
printf(" %3u %7u %7u %x.%x\n", ip.qlen, ip.servicetime,
ip.waittime, ip.cid, ip.call);
}
+ return 0;
}
#endif /* DUMPTRACE */
} else
scout_CleanExit(0);
+ return 0; /* not reachable */
} /*main */
strcat(*denv, fname5);
*++denv = 0;
environ = newenv;
+ return 0;
}
#endif
return NOPAG;
}
-
+void
afs_get_groups_from_pag(afs_uint32 pag, afs_uint32 * g0p, afs_uint32 * g1p)
{
unsigned short g0, g1;
* at some point... */
rx_SetMaxProcs(service, 2);
rx_StartServer(1); /* Donate this process to the server process pool */
+ return 0;
}
sprintf(tstring, "%s %d\n", tp->name, tp->rights);
strcat(mydata, tstring);
}
+ return 0;
}
free(te);
}
free(aa);
+ return 0;
}
status->PartBlocksAvail = htonl(status->PartBlocksAvail);
status->PartMaxBlocks = htonl(status->PartMaxBlocks);
}
+ return 0;
}
int
ticket->BeginTimestamp = htonl(ticket->BeginTimestamp);
ticket->EndTimestamp = htonl(ticket->EndTimestamp);
}
+ return 0;
}
int
/* Note that new pioctls are supposed to be in network order! */
break;
}
+ return 0;
}
/* Note that new pioctls are supposed to be in network order! */
break;
}
+ return 0;
}
* at some point... */
rx_SetMaxProcs(service, 2);
rx_StartServer(1); /* Donate this process to the server process pool */
+ return 0; /* not reached */
}
*/
/* procedure called from debug rpc call to get this module's state for debugging */
+void
ubeacon_Debug(aparm)
register struct ubik_debug *aparm;
{
char *s;
{
fprintf(stderr,"%s. ",s);
+return 0;
}
* and replaces the second with a null.
*/
+void
Replace(in, out)
char *in, *out;
if (doUnlog) {
code = uss_fs_UnlogToken(uss_Cell);
}
+ return 0;
} /*Main routine */
#endif /* USS_FS_DB */
return (-1);
}
-
+ return 0;
} /*uss_fs_MkMountPoint */
if (arights & DFS_USR7)
printf("H");
}
+ return 0;
}
/* this function returns TRUE (1) if the file is in AFS, otherwise false (0) */
} *allInfo = 0;
char dumpFileName[256] = "";
+void
RegisterIclDumpFileName(name)
char *name;
{
#if defined(AFS_SGI61_ENV) && !defined(AFS_SGI62_ENV)
#define uint64_t long long
#endif
-static
+static void
DisplayRecord(outFilep, alp, rsize)
FILE *outFilep;
register afs_int32 *alp;
#include <sys/time.h>
#include <sys/stat.h>
#include <fcntl.h>
+#include <stdio.h>
#include <unistd.h>
main(argc, argv)
dirName = argv[1];
mkdir(dirName, 0777);
if (chdir(dirName) < 0)
- return perror("chdir");
+ {perror("chdir");return;}
if (getcwd(tempName, 1024) == 0) {
return printf("Could not get working dir.\n");
}
/* now create some files */
fd1 = open("hi", O_CREAT | O_TRUNC | O_RDWR, 0666);
if (fd1 < 0)
- return perror("open1");
+ {perror("open1");return;}
if (close(fd1) < 0)
- return perror("close1");
+ {perror("close1");return;}
if (access("hi", 2) < 0)
return printf("New file can not be written (access)\n");
if (chmod("hi", 0741) < 0)
- return perror("chmod1");
+ {perror("chmod1");return;}
if (stat("hi", &tstat) < 0)
- return perror("stat1");
+ {perror("stat1");return;}
if ((tstat.st_mode & 0777) != 0741)
return printf("chmod failed to set mode properly\n");
fd1 = open("hi", O_RDWR);
if (fd1 < 0)
- return perror("open2");
+ {perror("open2");return;}
if (fchmod(fd1, 0654) < 0)
- return perror("fchmod");
+ {perror("fchmod");return;}
if (fstat(fd1, &tstat) < 0)
- return perror("fstat1");
+ {perror("fstat1");return;}
if ((tstat.st_mode & 0777) != 0654)
return printf("fchmod failed to set mode properly\n");
#if 0
/* These appear to be defunct routines;
* I don't know what, if anything, replaced them */
if (osi_ExclusiveLockNoBlock(fd1) < 0)
- return perror("flock1");
+ {perror("flock1");return;}
if (osi_UnLock(fd1) < 0)
- return perror("flock/unlock");
+ {perror("flock/unlock");return;}
#endif
/* How about shared lock portability? */
fl.l_len = 0;
if (fcntl(fd1, F_SETLK, &fl) == -1)
- return perror("fcntl1: RDLCK");
+ {perror("fcntl1: RDLCK");return;}
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
if (fcntl(fd1, F_SETLK, &fl) == -1)
- return perror("fcntl2: UNLCK");
+ {perror("fcntl2: UNLCK");return;}
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
if (fcntl(fd1, F_SETLK, &fl) == -1)
- return perror("fcntl3: WRLCK");
+ {perror("fcntl3: WRLCK");return;}
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
if (fcntl(fd1, F_SETLK, &fl) == -1)
- return perror("fcntl4: UNLCK");
+ {perror("fcntl4: UNLCK");return;}
}
if (fsync(fd1) < 0)
- return perror("fsync");
+ {perror("fsync");return;}
if (write(fd1, "hi\n", 3) != 3)
- return perror("write");
+ {perror("write");return;}
if (ftruncate(fd1, 2) < 0)
- return perror("ftruncate");
+ {perror("ftruncate");return;}
if (close(fd1) < 0)
- return perror("close2");
+ {perror("close2");return;}
fd1 = open("hi", O_RDONLY);
if (fd1 < 0)
- return perror("open3");
+ {perror("open3");return;}
if (read(fd1, tempName, 100) != 2)
- return perror("read2");
+ {perror("read2");return;}
if (close(fd1) < 0)
- return perror("close3");
+ {perror("close3");return;}
if (link("hi", "bye") < 0)
- return perror("link");
+ {perror("link");return;}
if (stat("bye", &tstat) < 0)
- return perror("link/stat");
+ {perror("link/stat");return;}
if (unlink("bye") < 0)
- return perror("unlink");
+ {perror("unlink");return;}
if (symlink("hi", "bye") < 0)
- return perror("symlink");
+ {perror("symlink");return;}
if (readlink("bye", tempName, 100) != 2)
- return perror("readlink");
+ {perror("readlink");return;}
if (strncmp(tempName, "hi", 2) != 0)
return printf("readlink contents");
if (mkdir("tdir", 0777) < 0)
- return perror("mkdir");
+ {perror("mkdir");return;}
fd1 = open("tdir/fdsa", O_CREAT | O_TRUNC, 0777);
close(fd1);
if (rmdir("tdir") == 0)
return printf("removed non-empty dir\n");
if (unlink("tdir/fdsa") < 0)
- return perror("unlink tdir contents");
+ {perror("unlink tdir contents");return;}
if (rmdir("tdir") < 0)
- return perror("rmdir");
+ {perror("rmdir");return;}
fd1 = open(".", O_RDONLY);
if (fd1 < 0)
- return perror("open dot");
+ {perror("open dot");return;}
if (read(fd1, tempName, 20) < 20)
perror("read dir");
close(fd1);
fd1 = open("rotest", O_RDWR | O_CREAT, 0444);
if (fd1 < 0)
- return perror("open ronly");
+ {perror("open ronly");return;}
fchown(fd1, 1, -1); /* don't check error code, may fail on Ultrix */
code = write(fd1, "test", 4);
if (code != 4) {
}
code = close(fd1);
if (code)
- return perror("close ronly");
+ {perror("close ronly");return;}
code = stat("rotest", &tstat);
if (code < 0)
- return perror("stat ronly");
+ {perror("stat ronly");return;}
if (tstat.st_size != 4) {
printf("rotest short close\n");
exit(1);
}
if (unlink("rotest") < 0)
- return perror("rotest unlink");
+ {perror("rotest unlink");return;}
if (rename("hi", "bye") < 0)
- return perror("rename1");
+ {perror("rename1");return;}
if (stat("bye", &tstat) < 0)
- return perror("rename target invisible\n");
+ {perror("rename target invisible\n");return;}
if (stat("hi", &tstat) == 0)
return printf("rename source still there\n");
#ifndef AFS_AIX_ENV
/* No truncate(2) on aix so the following are excluded */
if (truncate("bye", 1) < 0)
- return perror("truncate");
+ {perror("truncate");return;}
if (stat("bye", &tstat) < 0)
- return perror("truncate zapped");
+ {perror("truncate zapped");return;}
if (tstat.st_size != 1)
return printf("truncate failed\n");
#endif
if (utimes("bye", tvp) < 0)
- return perror("utimes");
+ {perror("utimes");return;}
if (unlink("bye") < 0)
- return perror("unlink bye");
+ {perror("unlink bye");return;}
/* now finish up */
chdir("..");
rmdir(dirName);
printf("Test completed successfully.\n");
+ return 0;
}
#include <afsconfig.h>
#include <afs/param.h>
+#include <stdio.h>
RCSID
("$Header$");
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
+#include <stdio.h>
RCSID
("$Header$");
#undef _NONSTD_TYPES
#endif
#include <stdio.h>
+#include <unistd.h>
#include <afs/afs_args.h>
#include <sys/param.h>
#ifdef AFS_SUN5_ENV
}
close(fd);
+ return 0;
}
#else /* AFS_PTHREAD_ENV */
assert(LWP_WaitProcess(&parentPid) == LWP_SUCCESS);
#endif /* AFS_PTHREAD_ENV */
+ return 0;
}
* verifying their address is not pass the EOF and the flags are good.
* If it's not good, then don't read the block in.
*/
+void
read_mhentries(mh_addr, oldfd)
int oldfd;
afs_uint32 mh_addr;
*
* Before this can be called, the routine read_mhentries must be called.
*/
+void
convert_mhentries(oldfd, newfd, header, fromver, tover)
int oldfd, newfd;
struct vlheader_2 *header;
if (headerp->vital_header.headersize != sizeof(*headerp))
printf("Header reports its size as %d (should be %d)\n",
headerp->vital_header.headersize, sizeof(*headerp));
+ return 0;
}
void
for (j = 0; j < VL_MAXIPADDRS_PERMH; j++)
e->ex_addrs[j] = ntohl(e->ex_addrs[j]);
}
+ return 0;
}
void
}
}
}
+ return 0;
}
void
("%d entries in name hash, longest is %d, shortest is %d, average length is %f\n",
count, longest, shortest, ((float)count / (float)HASHSIZE));
}
+ return 0;
}
/*
((float)count / (float)HASHSIZE));
}
}
+ return 0;
}
/*
}
if (verbose)
printf("%d entries on free chain\n", count);
+ return 0;
}
/*
printf("%d simple entries, %d multihomed entries, Total = %d\n",
regentries, mhentries, mhentries + regentries);
}
-
+ return 0;
}
void
static int put_attributeentry();
static int put_nattributeentry();
static int RemoveEntry();
-static ReleaseEntry();
+static void ReleaseEntry();
static int check_vldbentry();
static int check_nvldbentry();
static int vldbentry_to_vlentry();
static int nvldbentry_to_vlentry();
static get_vldbupdateentry();
static int repsite_exists();
-static repsite_compress();
-static vlentry_to_vldbentry();
-static vlentry_to_nvldbentry();
-static vlentry_to_uvldbentry();
+static void repsite_compress();
+static void vlentry_to_vldbentry();
+static void vlentry_to_nvldbentry();
+static void vlentry_to_uvldbentry();
static int InvalidVolname();
static int InvalidVoltype();
static int InvalidOperation();
return 0;
}
-static
+static void
ReleaseEntry(tentry, releasetype)
struct nvlentry *tentry;
afs_int32 releasetype;
/* Repsite table compression: used when deleting a repsite entry so that all active repsite entries are on the top of the table. */
-static
+static void
repsite_compress(VlEntry, offset)
struct nvlentry *VlEntry;
int offset;
/* Convert from the internal (compacted) vldb entry to the external representation used by the interface. */
-static
+static void
vlentry_to_vldbentry(VlEntry, VldbEntry)
struct nvlentry *VlEntry;
struct vldbentry *VldbEntry;
/* Convert from the internal (compacted) vldb entry to the external representation used by the interface. */
-static
+static void
vlentry_to_nvldbentry(VlEntry, VldbEntry)
struct nvlentry *VlEntry;
struct nvldbentry *VldbEntry;
VldbEntry->flags = VlEntry->flags;
}
-static
+static void
vlentry_to_uvldbentry(VlEntry, VldbEntry)
struct nvlentry *VlEntry;
struct uvldbentry *VldbEntry;
rx_SetRxStatUserOk(vldb_rxstat_userok);
rx_StartServer(1); /* Why waste this idle process?? */
+
+ return 0; /* not reachable */
}
#ifdef AFS_NAMEI_ENV
#include <stdio.h>
#include <stdlib.h>
+#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
err = cmd_Dispatch(argc, argv);
Exit(err);
+ return 0; /* not reached */
}
static void
#endif /* FAST_RESTART */
err = cmd_Dispatch(argc, argv);
Exit(err);
+ return 0; /* not reached */
}
}
/* Changes the RW site only */
+void
Lp_SetRWValue(entry, oserver, opart, nserver, npart)
struct nvldbentry *entry;
afs_int32 oserver, opart, nserver, npart;
}
/* Changes the RO site only */
+void
Lp_SetROValue(entry, oserver, opart, nserver, npart)
struct nvldbentry *entry;
afs_int32 oserver, opart, nserver, npart;
}
/*initialize queue pointed by <ahead>*/
+void
Lp_QInit(ahead)
struct qHead *ahead;
{
}
/*add <elem> in front of queue <ahead> */
+void
Lp_QAdd(ahead, elem)
struct qHead *ahead;
struct aqueue *elem;
/*return the element in the beginning of the queue <ahead>, free
*the space used by that element . <success> indicates if enumeration was ok*/
+void
Lp_QEnumerate(ahead, success, elem)
struct qHead *ahead;
struct aqueue *elem;
*success = 0;
}
+void
Lp_QTraverse(ahead)
struct qHead *ahead;
{
#define BUFSIZE 16384
char buf[BUFSIZE];
-char
+void
readdata(buffer, size)
char *buffer;
afs_sfsize_t size;
osi_audit(VS_FinishEvent, (-1), AUD_END);
Abort("StartServer returned?");
+ return 0; /* not reached */
}
code = AFSVolSetInfo(aconn, tid, &tstatus);
if (code)
- EPRINT(code, "Could not change quota (error %d), continuing...\n");
+ EPRINT(code, "Could not change quota, continuing...\n");
code = AFSVolSetFlags(aconn, tid, 0); /* bring it online (mark it InService */
EGOTO2(cfail, vcode, "Could not bring the volume %s %u online \n", aname,
/* Print detailed functional call statistics */
+void
print_cmCallStats()
{
static char rn[] = "print_cmCallStats"; /*Routine name */
git://git.openafs.org / openafs.git / commitdiff