}
static void
-DFlushBuffer(struct buffer *ab) {
+DFlushBuffer(struct buffer *ab)
+{
struct osi_file *tfile;
tfile = afs_CFileOpen(&ab->inode);
}
#endif
-int SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
- afs_int32 *inode, afs_int32 *flags, afs_int32 *time,
- char ** fileName)
+int
+SRXAFSCB_GetDE(struct rx_call *a_call, afs_int32 a_index, afs_int32 *addr,
+ afs_int32 *inode, afs_int32 *flags, afs_int32 *time,
+ char ** fileName)
{ /*SRXAFSCB_GetDE*/
int code = 0; /*Return code*/
#if 0 && defined(AFS_LINUX24_ENV)
* of 0)
*/
static struct rx_securityClass *
-afs_pickSecurityObject(struct afs_conn *conn, int *secLevel) {
+afs_pickSecurityObject(struct afs_conn *conn, int *secLevel)
+{
struct rx_securityClass *secObj = NULL;
/* Do we have tokens ? */
if (tb->opcode == BOP_FETCH)
BPrefetch(tb);
#if defined(AFS_CACHE_BYPASS)
- else if (tb->opcode == BOP_FETCH_NOCACHE)
+ else if (tb->opcode == BOP_FETCH_NOCACHE)
BPrefetchNoCache(tb);
#endif
else if (tb->opcode == BOP_STORE)
*
* \return The new dcache.
*/
-struct dcache *afs_AllocDCache(struct vcache *avc,
- afs_int32 chunk,
- afs_int32 lock,
- struct VenusFid *ashFid)
+struct dcache *
+afs_AllocDCache(struct vcache *avc, afs_int32 chunk, afs_int32 lock,
+ struct VenusFid *ashFid)
{
struct dcache *tdc = NULL;
afs_uint32 size = 0;
struct dcache *
afs_ObtainDCacheForWriting(struct vcache *avc, afs_size_t filePos,
afs_size_t len, struct vrequest *areq,
- int noLock) {
+ int noLock)
+{
struct dcache *tdc = NULL;
afs_size_t offset;
*/
static void
-afs_DisconDiscardAllShadows(int squash, afs_ucred_t *acred) {
+afs_DisconDiscardAllShadows(int squash, afs_ucred_t *acred)
+{
struct vcache *tvc;
while (!QEmpty(&afs_disconShadow)) {
*
*/
void
-afs_DisconDiscardAll(afs_ucred_t *acred) {
+afs_DisconDiscardAll(afs_ucred_t *acred)
+{
struct vcache *tvc;
ObtainWriteLock(&afs_disconDirtyLock, 717);
extern int cacheDiskType;
-
#ifndef AFS_NOSTATS
void
FillStoreStats(int code, int idx, osi_timeval_t *xferStartTime,
- afs_size_t bytesToXfer, afs_size_t bytesXferred)
+ afs_size_t bytesToXfer, afs_size_t bytesXferred)
{
struct afs_stats_xferData *xferP;
osi_timeval_t xferStopTime;
*/
afs_int32
afs_CacheStoreDCaches(struct vcache *avc, struct dcache **dclist,
- afs_size_t bytes,
- afs_hyper_t *anewDV,
- int *doProcessFS,
- struct AFSFetchStatus *OutStatus,
- afs_uint32 nchunks,
- int nomore,
- struct storeOps *ops, void *rock)
+ afs_size_t bytes, afs_hyper_t *anewDV, int *doProcessFS,
+ struct AFSFetchStatus *OutStatus, afs_uint32 nchunks,
+ int nomore, struct storeOps *ops, void *rock)
{
int *shouldwake = NULL;
unsigned int i;
*/
int
afs_CacheStoreVCache(struct dcache **dcList, struct vcache *avc,
- struct vrequest *areq, int sync,
- unsigned int minj, unsigned int high,
- unsigned int moredata,
- afs_hyper_t *anewDV, afs_size_t *amaxStoredLength)
+ struct vrequest *areq, int sync, unsigned int minj,
+ unsigned int high, unsigned int moredata,
+ afs_hyper_t *anewDV, afs_size_t *amaxStoredLength)
{
afs_int32 code = 0;
struct storeOps *ops;
afs_int32
-rxfs_fetchMemWrite(void *r, struct osi_file *fP,
- afs_uint32 offset, afs_uint32 tlen,
- afs_uint32 *byteswritten)
+rxfs_fetchMemWrite(void *r, struct osi_file *fP, afs_uint32 offset,
+ afs_uint32 tlen, afs_uint32 *byteswritten)
{
afs_int32 code;
struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
}
afs_int32
-rxfs_fetchUfsWrite(void *r, struct osi_file *fP,
- afs_uint32 offset, afs_uint32 tlen,
- afs_uint32 *byteswritten)
+rxfs_fetchUfsWrite(void *r, struct osi_file *fP, afs_uint32 offset,
+ afs_uint32 tlen, afs_uint32 *byteswritten)
{
afs_int32 code;
struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
afs_int32
rxfs_fetchClose(void *r, struct vcache *avc, struct dcache * adc,
- struct afs_FetchOutput *o)
+ struct afs_FetchOutput *o)
{
afs_int32 code, code1 = 0;
struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
afs_int32
rxfs_fetchInit(struct afs_conn *tc, struct vcache *avc, afs_offs_t base,
- afs_uint32 size, afs_int32 *alength, struct dcache *adc,
- struct osi_file *fP, struct fetchOps **ops, void **rock)
+ afs_uint32 size, afs_int32 *alength, struct dcache *adc,
+ struct osi_file *fP, struct fetchOps **ops, void **rock)
{
struct rxfs_fetchVariables *v;
int code = 0, code1 = 0;
#endif
afs_uint32 length, bytes;
- v = (struct rxfs_fetchVariables *) osi_AllocSmallSpace(sizeof(struct rxfs_fetchVariables));
+ v = (struct rxfs_fetchVariables *)
+ osi_AllocSmallSpace(sizeof(struct rxfs_fetchVariables));
if (!v)
osi_Panic("rxfs_fetchInit: osi_AllocSmallSpace returned NULL\n");
memset(v, 0, sizeof(struct rxfs_fetchVariables));
if (!afs_serverHasNo64Bit(tc)) {
afs_uint64 llbytes = size;
RX_AFS_GUNLOCK();
- code = StartRXAFS_FetchData64(v->call, (struct AFSFid *) &avc->f.fid.Fid,
- base, llbytes);
+ code = StartRXAFS_FetchData64(v->call,
+ (struct AFSFid *) &avc->f.fid.Fid,
+ base, llbytes);
if (code != 0) {
RX_AFS_GLOCK();
afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
*/
int
afs_CacheFetchProc(struct afs_conn *tc, struct osi_file *fP, afs_size_t base,
- struct dcache *adc, struct vcache *avc, afs_int32 size,
- struct afs_FetchOutput *tsmall)
+ struct dcache *adc, struct vcache *avc, afs_int32 size,
+ struct afs_FetchOutput *tsmall)
{
afs_int32 code;
afs_int32 length;
int
afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32 ablocks,
afs_int32 aDentries, afs_int32 aVolumes, afs_int32 achunk,
- afs_int32 aflags, afs_int32 ninodes, afs_int32 nusers, afs_int32 dynamic_vcaches)
+ afs_int32 aflags, afs_int32 ninodes, afs_int32 nusers,
+ afs_int32 dynamic_vcaches)
{
register afs_int32 i;
register struct volume *tv;
* If the vnode is not returned, we rele it.
*/
int
-afs_LookupInodeByPath(char *filename, afs_ufs_dcache_id_t *inode, struct vnode **fvpp)
+afs_LookupInodeByPath(char *filename, afs_ufs_dcache_id_t *inode,
+ struct vnode **fvpp)
{
afs_int32 code;
}
void
-afs_nfsclient_getcreds(au)
- struct unixuser *au;
+afs_nfsclient_getcreds(struct unixuser *au)
{
struct nfsclientpag *np = (struct nfsclientpag *)(au->exporter);
struct rx_securityClass *csec;
}
-/* It's called whenever a new unixuser structure is created for the remote user associated with the nfsclientpag structure, np */
+/* It's called whenever a new unixuser structure is created for the remote
+ * user associated with the nfsclientpag structure, np */
void
-afs_nfsclient_hold(np)
- register struct nfsclientpag *np;
+afs_nfsclient_hold(register struct nfsclientpag *np)
{
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
/* check if this exporter corresponds to the specified host */
int
-afs_nfsclient_checkhost(np, host)
- register struct nfsclientpag *np;
+afs_nfsclient_checkhost(register struct nfsclientpag *np, int host)
{
if (np->type != EXP_NFS)
return 0;
/* get the host for this exporter, or 0 if there is an error */
afs_int32
-afs_nfsclient_gethost(np)
- register struct nfsclientpag *np;
+afs_nfsclient_gethost(register struct nfsclientpag *np)
{
if (np->type != EXP_NFS)
return 0;
}
-/* if inname is non-null, a new system name value is set for the remote user (inname contains the new sysname). In all cases, outname returns the current sysname value for this remote user */
+/* if inname is non-null, a new system name value is set for the remote
+ * user (inname contains the new sysname). In all cases, outname returns
+ * the current sysname value for this remote user */
int
afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname,
char ***outname, int *num, int allpags)
}
-/* Garbage collect routine for the nfs exporter. When pag is -1 then all entries are removed (used by the nfsclient_shutdown routine); else if it's non zero then only the entry with that pag is removed, else all "timedout" entries are removed. TimedOut entries are those who have no "unixuser" structures associated with them (i.e. unixusercnt == 0) and they haven't had any activity the last NFSCLIENTGC seconds */
+/* Garbage collect routine for the nfs exporter. When pag is -1 then all
+ * entries are removed (used by the nfsclient_shutdown routine); else if
+ * it's non zero then only the entry with that pag is removed, else all
+ * "timedout" entries are removed. TimedOut entries are those who have no
+ * "unixuser" structures associated with them (i.e. unixusercnt == 0) and
+ * they haven't had any activity the last NFSCLIENTGC seconds */
void
-afs_nfsclient_GC(exporter, pag)
- register struct afs_exporter *exporter;
- register afs_int32 pag;
+afs_nfsclient_GC(register struct afs_exporter *exporter,
+ register afs_int32 pag)
{
register struct nfsclientpag *np, **tnp, *nnp;
register afs_int32 i, delflag;
* and -1 on failure. Can fail because DFS has already registered.
*/
int
-afs_iauth_register()
+afs_iauth_register(void)
{
if (nfs_iauth_register((unsigned long)afs_nfs_id, afs_iauth_verify))
return -1;
/* afs_iauth_unregister - unregister the iauth verify routine. Called on shutdown.
*/
void
-afs_iauth_unregister()
+afs_iauth_unregister(void)
{
if (afs_iauth_initd)
nfs_iauth_unregister((unsigned long)afs_nfs_id);
void
-shutdown_nfsclnt()
+shutdown_nfsclnt(void)
{
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
/* Two hacks to try and fix afsdb */
void
-afs_osi_MaskUserLoop()
+afs_osi_MaskUserLoop(void)
{
#ifdef AFS_DARWIN_ENV
afs_osi_Invisible();
extern rwlock_t tasklist_lock __attribute__((weak));
#endif
void
-afs_osi_TraverseProcTable()
+afs_osi_TraverseProcTable(void)
{
#if !defined(LINUX_KEYRING_SUPPORT) && (!defined(STRUCT_TASK_HAS_CRED) || defined(EXPORTED_RCU_READ_LOCK))
struct task_struct *p;
afs_int32 afs_showflags = GAGUSER | GAGCONSOLE; /* show all messages */
-void afs_Daemon(void)
+void
+afs_Daemon(void)
{
afs_int32 now, last10MinCheck, last60MinCheck;
}
-void afspag_Init(afs_int32 nfs_server_addr)
+void
+afspag_Init(afs_int32 nfs_server_addr)
{
struct clientcred ccred;
struct rmtbulk idata, odata;
/* called with the GLOCK held */
-void afspag_Shutdown(void)
+void
+afspag_Shutdown(void)
{
if (afs_shuttingdown)
return;
#endif
}
-static void token_conversion(char *buffer, int buf_size, int in)
+static void
+token_conversion(char *buffer, int buf_size, int in)
{
struct ClearToken *ticket;
afs_int32 *lptr, n;
return;
}
-static void FetchVolumeStatus_conversion(char *buffer, int buf_size, int in)
+static void
+FetchVolumeStatus_conversion(char *buffer, int buf_size, int in)
{
AFSFetchVolumeStatus *status = (AFSFetchVolumeStatus *)buffer;
}
}
-static void inparam_conversion(int cmd, char *buffer, int buf_size, int in)
+static void
+inparam_conversion(int cmd, char *buffer, int buf_size, int in)
{
afs_int32 *lptr = (afs_int32 *)buffer;
}
}
-static void outparam_conversion(int cmd, char *buffer, int buf_size, int in)
+static void
+outparam_conversion(int cmd, char *buffer, int buf_size, int in)
{
afs_int32 *lptr = (afs_int32 *)buffer;
int i;
static struct afspag_cell *primary_cell = 0;
-struct afspag_cell *afspag_GetCell(char *acell)
+struct afspag_cell *
+afspag_GetCell(char *acell)
{
struct afspag_cell *tcell;
}
-struct afspag_cell *afspag_GetPrimaryCell()
+struct afspag_cell *
+afspag_GetPrimaryCell(void)
{
struct afspag_cell *tcell;
}
-void afspag_SetPrimaryCell(char *acell)
+void
+afspag_SetPrimaryCell(char *acell)
{
struct afspag_cell *tcell;
}
-int afspag_PUnlog(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
+int
+afspag_PUnlog(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
register afs_int32 i;
register struct unixuser *tu;
}
-int afspag_PSetTokens(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
+int
+afspag_PSetTokens(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
afs_int32 i;
register struct unixuser *tu;
}
-int afspag_PSetSysName(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
+int
+afspag_PSetSysName(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
int setsysname, count, t;
char *cp, *setp;
*/
static_inline int
-afs_pd_alloc(struct afs_pdata *apd, size_t size) {
+afs_pd_alloc(struct afs_pdata *apd, size_t size)
+{
if (size > AFS_LRALLOCSIZ)
apd->ptr = osi_Alloc(size + 1);
}
static_inline void
-afs_pd_free(struct afs_pdata *apd) {
+afs_pd_free(struct afs_pdata *apd)
+{
if (apd->ptr == NULL)
return;
}
static_inline char *
-afs_pd_where(struct afs_pdata *apd) {
+afs_pd_where(struct afs_pdata *apd)
+{
return apd ? apd->ptr : NULL;
}
static_inline size_t
-afs_pd_remaining(struct afs_pdata *apd) {
+afs_pd_remaining(struct afs_pdata *apd)
+{
return apd ? apd->remaining : 0;
}
static_inline int
-afs_pd_skip(struct afs_pdata *apd, size_t skip) {
+afs_pd_skip(struct afs_pdata *apd, size_t skip)
+{
if (apd == NULL || apd->remaining < skip)
return EINVAL;
apd->remaining -= skip;
}
static_inline int
-afs_pd_getInt(struct afs_pdata *apd, afs_int32 *val) {
+afs_pd_getInt(struct afs_pdata *apd, afs_int32 *val)
+{
if (apd == NULL || apd->remaining < sizeof(afs_int32))
return EINVAL;
apd->remaining -= sizeof(afs_int32);
}
static_inline int
-afs_pd_getUint(struct afs_pdata *apd, afs_uint32 *val) {
+afs_pd_getUint(struct afs_pdata *apd, afs_uint32 *val)
+{
return afs_pd_getInt(apd, (afs_int32 *)val);
}
static_inline int
-afs_pd_getBytes(struct afs_pdata *apd, void *dest, size_t bytes) {
+afs_pd_getBytes(struct afs_pdata *apd, void *dest, size_t bytes)
+{
if (apd == NULL || apd->remaining < bytes)
return EINVAL;
apd->remaining -= bytes;
}
static_inline void *
-afs_pd_inline(struct afs_pdata *apd, size_t bytes) {
+afs_pd_inline(struct afs_pdata *apd, size_t bytes)
+{
void *ret;
if (apd == NULL || apd->remaining < bytes)
}
static_inline int
-afs_pd_getString(struct afs_pdata *apd, char *str, size_t maxLen) {
+afs_pd_getString(struct afs_pdata *apd, char *str, size_t maxLen)
+{
size_t len;
if (apd == NULL || apd->remaining <= 0)
}
static_inline int
-afs_pd_getStringPtr(struct afs_pdata *apd, char **str) {
+afs_pd_getStringPtr(struct afs_pdata *apd, char **str)
+{
size_t len;
if (apd == NULL || apd->remaining <= 0)
}
static_inline int
-afs_pd_putInt(struct afs_pdata *apd, afs_int32 val) {
+afs_pd_putInt(struct afs_pdata *apd, afs_int32 val)
+{
if (apd == NULL || apd->remaining < sizeof(afs_int32))
return E2BIG;
*(afs_int32 *)apd->ptr = val;
}
static_inline int
-afs_pd_putBytes(struct afs_pdata *apd, const void *bytes, size_t len) {
+afs_pd_putBytes(struct afs_pdata *apd, const void *bytes, size_t len)
+{
if (apd == NULL || apd->remaining < len)
return E2BIG;
memcpy(apd->ptr, bytes, len);
*
* \post Changed ACL, via direct writing to the wire
*/
-int dummy_PSetAcl(char *ain, char *aout)
+int
+dummy_PSetAcl(char *ain, char *aout)
{
return 0;
}
* \note avc must be write locked. May release and reobtain avc and GLOCK
*/
int
-afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq) {
+afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq)
+{
afs_size_t offset, toAdd;
struct osi_file *tfile;
afs_int32 code = 0;
#define afs_min(A,B) ((A)<(B)) ? (A) : (B)
#endif
void
-afsi_SetServerIPRank(sa, ifa)
- struct srvAddr *sa;
- rx_ifaddr_t ifa;
+afsi_SetServerIPRank(struct srvAddr *sa, rx_ifaddr_t ifa)
{
struct sockaddr sout;
struct sockaddr_in *sin;
#ifdef AFS_SGI62_ENV
static int
-
- afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
- caddr_t arg2) {
+afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
+ caddr_t arg2)
+{
afsi_SetServerIPRank((struct srvAddr *)arg1, (struct in_ifaddr *)h);
return 0; /* Never match, so we enumerate everyone */
}
#endif /* AFS_SGI62_ENV */
-static int afs_SetServerPrefs(struct srvAddr *sa) {
+static int
+afs_SetServerPrefs(struct srvAddr *sa)
+{
#if defined(AFS_USERSPACE_IP_ADDR)
int i;
* clean up all other structures that may reference it.
* The afs_xserver and afs_xsrvAddr locks are assumed taken.
*/
-void afs_FlushServer(struct server *srvp) {
+void
+afs_FlushServer(struct server *srvp)
+{
afs_int32 i;
struct server *ts, **pts;
* The afs_xserver and afs_xsrvAddr locks are assumed taken.
* It is not removed from the afs_srvAddrs hash chain.
*/
-void afs_RemoveSrvAddr(struct srvAddr *sap) {
+void
+afs_RemoveSrvAddr(struct srvAddr *sap)
+{
struct srvAddr **psa, *sa;
struct server *srv;
* If one does not exist, then one will be created.
* aserver and aport must be in NET byte order.
*/
-struct server *afs_GetServer(afs_uint32 * aserverp, afs_int32 nservers,
- afs_int32 acell, u_short aport,
- afs_int32 locktype, afsUUID * uuidp,
- afs_int32 addr_uniquifier) {
+struct server *
+afs_GetServer(afs_uint32 * aserverp, afs_int32 nservers, afs_int32 acell,
+ u_short aport, afs_int32 locktype, afsUUID * uuidp,
+ afs_int32 addr_uniquifier)
+{
struct server *oldts = 0, *ts, *newts, *orphts = 0;
struct srvAddr *oldsa, *newsa, *nextsa, *orphsa;
u_short fsport;
return (newts);
} /* afs_GetServer */
-void afs_ActivateServer(struct srvAddr *sap) {
+void
+afs_ActivateServer(struct srvAddr *sap)
+{
osi_timeval_t currTime; /*Filled with current time */
osi_timeval_t *currTimeP; /*Ptr to above */
struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record */
}
}
-void afs_RemoveAllConns(void)
+void
+afs_RemoveAllConns(void)
{
int i;
struct server *ts, *nts;
}
-void afs_MarkAllServersUp(void)
+void
+afs_MarkAllServersUp(void)
{
int i;
struct server *ts;
* PAG to expire records for
*/
void
-afs_MarkUserExpired(afs_int32 pag) {
+afs_MarkUserExpired(afs_int32 pag)
+{
afs_int32 i;
struct unixuser *tu;
#ifdef AFS_LINUX20_ENV
-afs_int32 afs_calc_inum (afs_int32 volume, afs_int32 vnode)
+afs_int32
+afs_calc_inum(afs_int32 volume, afs_int32 vnode)
{
afs_int32 ino, vno = vnode;
char digest[16];
#else
-afs_int32 afs_calc_inum (afs_int32 volume, afs_int32 vnode)
+afs_int32
+afs_calc_inum (afs_int32 volume, afs_int32 vnode)
{
return (volume << 16) + vnode;
}
*
* \note Must be called with a shared lock on the vnode
*/
-int afs_WriteVCacheDiscon(register struct vcache *avc,
- register struct AFSStoreStatus *astatus,
- struct vattr *attrs)
+int
+afs_WriteVCacheDiscon(register struct vcache *avc,
+ register struct AFSStoreStatus *astatus,
+ struct vattr *attrs)
{
afs_int32 code = 0;
afs_int32 flags = 0;
* \note The vcache must be write locked.
*/
void
-afs_UpdateStatus(struct vcache *avc,
- struct VenusFid *afid,
- struct vrequest *areq,
- struct AFSFetchStatus *Outsp,
- struct AFSCallBack *acb,
- afs_uint32 start)
+afs_UpdateStatus(struct vcache *avc, struct VenusFid *afid,
+ struct vrequest *areq, struct AFSFetchStatus *Outsp,
+ struct AFSCallBack *acb, afs_uint32 start)
{
struct volume *volp;
* \note avc must be write locked on entry
*/
void
-afs_ResetVCache(struct vcache *avc, afs_ucred_t *acred) {
+afs_ResetVCache(struct vcache *avc, afs_ucred_t *acred)
+{
ObtainWriteLock(&afs_xcbhash, 456);
afs_DequeueCallback(avc);
avc->f.states &= ~(CStatd | CDirty); /* next reference will re-stat */
*
* \return
*/
-static void findvc_sleep(struct vcache *avc, int flag) {
+static void
+findvc_sleep(struct vcache *avc, int flag)
+{
if (flag & IS_SLOCK) {
ReleaseSharedLock(&afs_xvcache);
} else {
}
void
-afs_DisconGiveUpCallbacks(void) {
+afs_DisconGiveUpCallbacks(void)
+{
int i;
struct vcache *tvc;
int nq=0;
*
*/
void
-afs_ClearAllStatdFlag(void) {
+afs_ClearAllStatdFlag(void)
+{
int i;
struct vcache *tvc;
# define afs_vprintf(fmt, ap) icmn_err(CE_WARN, fmt, ap)
#elif (defined(AFS_DARWIN80_ENV) && !defined(AFS_DARWIN90_ENV)) || (defined(AFS_LINUX22_ENV))
static_inline void
-afs_vprintf(const char *fmt, va_list ap) {
+afs_vprintf(const char *fmt, va_list ap)
+{
char buf[256];
vsnprintf(buf, sizeof(buf), fmt, ap);
git://git.openafs.org / openafs.git / commitdiff