sync
This commit is contained in:
parent
6871d7cb85
commit
451579e149
GPG key ID:
F42C07F07E2E35B7
103 changed files with 365 additions and 470 deletions
|
|
@ -81,5 +81,6 @@ _sndiop:*:110:
|
|||
_syspatch:*:112:
|
||||
_slaacd:*:115:
|
||||
dialer:*:117:
|
||||
_shutdown:*:118:
|
||||
nogroup:*:32766:
|
||||
nobody:*:32767:
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
/* $OpenBSD: ecdsa.h,v 1.15 2023/04/18 08:47:28 tb Exp $ */
|
||||
/**
|
||||
* \file crypto/ecdsa/ecdsa.h Include file for the OpenSSL ECDSA functions
|
||||
* \author Written by Nils Larsch for the OpenSSL project
|
||||
/* $OpenBSD: ecdsa.h,v 1.16 2023/06/19 09:12:41 tb Exp $ */
|
||||
/*
|
||||
* Written by Nils Larsch for the OpenSSL project
|
||||
*/
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved.
|
||||
|
|
@ -88,7 +87,8 @@ struct ecdsa_method {
|
|||
char *app_data;
|
||||
};
|
||||
|
||||
/* If this flag is set the ECDSA method is FIPS compliant and can be used
|
||||
/*
|
||||
* If this flag is set, the ECDSA method is FIPS compliant and can be used
|
||||
* in FIPS mode. This is set in the validated module method. If an
|
||||
* application sets this flag in its own methods it is its responsibility
|
||||
* to ensure the result is compliant.
|
||||
|
|
@ -96,172 +96,44 @@ struct ecdsa_method {
|
|||
|
||||
#define ECDSA_FLAG_FIPS_METHOD 0x1
|
||||
|
||||
/** Allocates and initialize a ECDSA_SIG structure
|
||||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred
|
||||
*/
|
||||
ECDSA_SIG *ECDSA_SIG_new(void);
|
||||
|
||||
/** frees a ECDSA_SIG structure
|
||||
* \param sig pointer to the ECDSA_SIG structure
|
||||
*/
|
||||
void ECDSA_SIG_free(ECDSA_SIG *sig);
|
||||
|
||||
/** DER encode content of ECDSA_SIG object (note: this function modifies *pp
|
||||
* (*pp += length of the DER encoded signature)).
|
||||
* \param sig pointer to the ECDSA_SIG object
|
||||
* \param pp pointer to a unsigned char pointer for the output or NULL
|
||||
* \return the length of the DER encoded ECDSA_SIG object or 0
|
||||
*/
|
||||
int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
|
||||
|
||||
/** Decodes a DER encoded ECDSA signature (note: this function changes *pp
|
||||
* (*pp += len)).
|
||||
* \param sig pointer to ECDSA_SIG pointer (may be NULL)
|
||||
* \param pp memory buffer with the DER encoded signature
|
||||
* \param len length of the buffer
|
||||
* \return pointer to the decoded ECDSA_SIG structure (or NULL)
|
||||
*/
|
||||
ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len);
|
||||
|
||||
/** Accessor for r and s fields of ECDSA_SIG
|
||||
* \param sig pointer to ECDSA_SIG pointer
|
||||
* \param pr pointer to BIGNUM pointer for r (may be NULL)
|
||||
* \param ps pointer to BIGNUM pointer for s (may be NULL)
|
||||
*/
|
||||
void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
|
||||
|
||||
const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig);
|
||||
const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig);
|
||||
|
||||
/** Setter for r and s fields of ECDSA_SIG
|
||||
* \param sig pointer to ECDSA_SIG pointer
|
||||
* \param r pointer to BIGNUM for r (may be NULL)
|
||||
* \param s pointer to BIGNUM for s (may be NULL)
|
||||
*/
|
||||
int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
|
||||
|
||||
/** Computes the ECDSA signature of the given hash value using
|
||||
* the supplied private key and returns the created signature.
|
||||
* \param dgst pointer to the hash value
|
||||
* \param dgst_len length of the hash value
|
||||
* \param eckey EC_KEY object containing a private EC key
|
||||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred
|
||||
*/
|
||||
ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
|
||||
EC_KEY *eckey);
|
||||
|
||||
/** Computes ECDSA signature of a given hash value using the supplied
|
||||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
|
||||
* \param dgst pointer to the hash value to sign
|
||||
* \param dgstlen length of the hash value
|
||||
* \param kinv BIGNUM with a pre-computed inverse k (optional)
|
||||
* \param rp BIGNUM with a pre-computed rp value (optional),
|
||||
* see ECDSA_sign_setup
|
||||
* \param eckey EC_KEY object containing a private EC key
|
||||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred
|
||||
*/
|
||||
ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
|
||||
const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);
|
||||
|
||||
/** Verifies that the supplied signature is a valid ECDSA
|
||||
* signature of the supplied hash value using the supplied public key.
|
||||
* \param dgst pointer to the hash value
|
||||
* \param dgst_len length of the hash value
|
||||
* \param sig ECDSA_SIG structure
|
||||
* \param eckey EC_KEY object containing a public EC key
|
||||
* \return 1 if the signature is valid, 0 if the signature is invalid
|
||||
* and -1 on error
|
||||
*/
|
||||
int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
|
||||
const ECDSA_SIG *sig, EC_KEY* eckey);
|
||||
|
||||
const ECDSA_METHOD *ECDSA_OpenSSL(void);
|
||||
|
||||
/** Sets the default ECDSA method
|
||||
* \param meth new default ECDSA_METHOD
|
||||
*/
|
||||
void ECDSA_set_default_method(const ECDSA_METHOD *meth);
|
||||
|
||||
/** Returns the default ECDSA method
|
||||
* \return pointer to ECDSA_METHOD structure containing the default method
|
||||
*/
|
||||
const ECDSA_METHOD *ECDSA_get_default_method(void);
|
||||
|
||||
/** Sets method to be used for the ECDSA operations
|
||||
* \param eckey EC_KEY object
|
||||
* \param meth new method
|
||||
* \return 1 on success and 0 otherwise
|
||||
*/
|
||||
int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth);
|
||||
|
||||
/** Returns the maximum length of the DER encoded signature
|
||||
* \param eckey EC_KEY object
|
||||
* \return numbers of bytes required for the DER encoded signature
|
||||
*/
|
||||
int ECDSA_size(const EC_KEY *eckey);
|
||||
|
||||
/** Precompute parts of the signing operation
|
||||
* \param eckey EC_KEY object containing a private EC key
|
||||
* \param ctx BN_CTX object (optional)
|
||||
* \param kinv BIGNUM pointer for the inverse of k
|
||||
* \param rp BIGNUM pointer for x coordinate of k * generator
|
||||
* \return 1 on success and 0 otherwise
|
||||
*/
|
||||
int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
|
||||
BIGNUM **rp);
|
||||
|
||||
/** Computes ECDSA signature of a given hash value using the supplied
|
||||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
|
||||
* \param type this parameter is ignored
|
||||
* \param dgst pointer to the hash value to sign
|
||||
* \param dgstlen length of the hash value
|
||||
* \param sig memory for the DER encoded created signature
|
||||
* \param siglen pointer to the length of the returned signature
|
||||
* \param eckey EC_KEY object containing a private EC key
|
||||
* \return 1 on success and 0 otherwise
|
||||
*/
|
||||
int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
|
||||
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
|
||||
|
||||
|
||||
/** Computes ECDSA signature of a given hash value using the supplied
|
||||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
|
||||
* \param type this parameter is ignored
|
||||
* \param dgst pointer to the hash value to sign
|
||||
* \param dgstlen length of the hash value
|
||||
* \param sig buffer to hold the DER encoded signature
|
||||
* \param siglen pointer to the length of the returned signature
|
||||
* \param kinv BIGNUM with a pre-computed inverse k (optional)
|
||||
* \param rp BIGNUM with a pre-computed rp value (optional),
|
||||
* see ECDSA_sign_setup
|
||||
* \param eckey EC_KEY object containing a private EC key
|
||||
* \return 1 on success and 0 otherwise
|
||||
*/
|
||||
int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
|
||||
unsigned char *sig, unsigned int *siglen, const BIGNUM *kinv,
|
||||
const BIGNUM *rp, EC_KEY *eckey);
|
||||
|
||||
/** Verifies that the given signature is valid ECDSA signature
|
||||
* of the supplied hash value using the specified public key.
|
||||
* \param type this parameter is ignored
|
||||
* \param dgst pointer to the hash value
|
||||
* \param dgstlen length of the hash value
|
||||
* \param sig pointer to the DER encoded signature
|
||||
* \param siglen length of the DER encoded signature
|
||||
* \param eckey EC_KEY object containing a public EC key
|
||||
* \return 1 if the signature is valid, 0 if the signature is invalid
|
||||
* and -1 on error
|
||||
*/
|
||||
int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen,
|
||||
const unsigned char *sig, int siglen, EC_KEY *eckey);
|
||||
|
||||
/* the standard ex_data functions */
|
||||
int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
||||
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
||||
int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
|
||||
void *ECDSA_get_ex_data(EC_KEY *d, int idx);
|
||||
|
||||
|
||||
/* XXX should be in ec.h, but needs ECDSA_SIG */
|
||||
void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
|
||||
int (*sign)(int type, const unsigned char *dgst,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls_signer.c,v 1.6 2023/06/18 11:43:03 op Exp $ */
|
||||
/* $OpenBSD: tls_signer.c,v 1.9 2023/06/18 19:12:58 tb Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2021 Eric Faurot <eric@openbsd.org>
|
||||
*
|
||||
|
|
@ -392,8 +392,8 @@ tls_ecdsa_do_sign(const unsigned char *dgst, int dgst_len, const BIGNUM *inv,
|
|||
* to its calling convention/signature.
|
||||
*/
|
||||
|
||||
pubkey_hash = ECDSA_get_ex_data(eckey, 0);
|
||||
config = ECDSA_get_ex_data(eckey, 1);
|
||||
pubkey_hash = EC_KEY_get_ex_data(eckey, 0);
|
||||
config = EC_KEY_get_ex_data(eckey, 1);
|
||||
|
||||
if (pubkey_hash == NULL || config == NULL)
|
||||
goto err;
|
||||
|
|
@ -423,17 +423,26 @@ EC_KEY_METHOD *
|
|||
tls_signer_ecdsa_method(void)
|
||||
{
|
||||
static EC_KEY_METHOD *ecdsa_method = NULL;
|
||||
const EC_KEY_METHOD *default_method;
|
||||
int (*sign)(int type, const unsigned char *dgst, int dlen,
|
||||
unsigned char *sig, unsigned int *siglen,
|
||||
const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey);
|
||||
int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
|
||||
BIGNUM **kinvp, BIGNUM **rp);
|
||||
|
||||
pthread_mutex_lock(&signer_method_lock);
|
||||
|
||||
if (ecdsa_method != NULL)
|
||||
goto out;
|
||||
|
||||
ecdsa_method = EC_KEY_METHOD_new(NULL);
|
||||
default_method = EC_KEY_get_default_method();
|
||||
ecdsa_method = EC_KEY_METHOD_new(default_method);
|
||||
if (ecdsa_method == NULL)
|
||||
goto out;
|
||||
|
||||
EC_KEY_METHOD_set_sign(ecdsa_method, NULL, NULL, tls_ecdsa_do_sign);
|
||||
EC_KEY_METHOD_get_sign(default_method, &sign, &sign_setup, NULL);
|
||||
EC_KEY_METHOD_set_sign(ecdsa_method, sign, sign_setup,
|
||||
tls_ecdsa_do_sign);
|
||||
|
||||
out:
|
||||
pthread_mutex_unlock(&signer_method_lock);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: disklabel.c,v 1.249 2023/05/13 18:13:42 krw Exp $ */
|
||||
/* $OpenBSD: disklabel.c,v 1.250 2023/06/19 13:45:19 krw Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1987, 1993
|
||||
|
|
@ -367,13 +367,13 @@ parsefstab(void)
|
|||
|
||||
i = asprintf(&partname, "/dev/%s%c", dkname, 'a');
|
||||
if (i == -1)
|
||||
err(4, NULL);
|
||||
err(1, NULL);
|
||||
i = asprintf(&partduid,
|
||||
"%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx.a",
|
||||
lab.d_uid[0], lab.d_uid[1], lab.d_uid[2], lab.d_uid[3],
|
||||
lab.d_uid[4], lab.d_uid[5], lab.d_uid[6], lab.d_uid[7]);
|
||||
if (i == -1)
|
||||
err(4, NULL);
|
||||
err(1, NULL);
|
||||
setfsent();
|
||||
for (i = 0; i < MAXPARTITIONS; i++) {
|
||||
partname[strlen(dkname) + 5] = 'a' + i;
|
||||
|
|
@ -812,7 +812,7 @@ getasciilabel(FILE *f, struct disklabel *lp)
|
|||
lp->d_version = 1;
|
||||
|
||||
if (!(omountpoints = calloc(MAXPARTITIONS, sizeof(char *))))
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
|
||||
mpcopy(omountpoints, mountpoints);
|
||||
for (part = 0; part < MAXPARTITIONS; part++) {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: editor.c,v 1.407 2023/05/23 13:20:31 krw Exp $ */
|
||||
/* $OpenBSD: editor.c,v 1.410 2023/06/19 13:45:19 krw Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1997-2000 Todd C. Miller <millert@openbsd.org>
|
||||
|
|
@ -44,6 +44,7 @@
|
|||
|
||||
#define ROUNDUP(_s, _a) ((((_s) + (_a) - 1) / (_a)) * (_a))
|
||||
#define ROUNDDOWN(_s, _a) (((_s) / (_a)) * (_a))
|
||||
#define CHUNKSZ(_c) ((_c)->stop - (_c)->start)
|
||||
|
||||
/* flags for getuint64() */
|
||||
#define DO_CONVERSIONS 0x00000001
|
||||
|
|
@ -197,7 +198,7 @@ editor(int f)
|
|||
if (!(omountpoints = calloc(MAXPARTITIONS, sizeof(char *))) ||
|
||||
!(origmountpoints = calloc(MAXPARTITIONS, sizeof(char *))) ||
|
||||
!(tmpmountpoints = calloc(MAXPARTITIONS, sizeof(char *))))
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
|
||||
/* How big is the OpenBSD portion of the disk? */
|
||||
find_bounds(&newlab);
|
||||
|
|
@ -404,11 +405,11 @@ editor(int f)
|
|||
/* Display free space. */
|
||||
chunk = free_chunks(&newlab, -1);
|
||||
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
|
||||
total += chunk->stop - chunk->start;
|
||||
total += CHUNKSZ(chunk);
|
||||
fprintf(stderr, "Free sectors: %16llu - %16llu "
|
||||
"(%16llu)\n",
|
||||
chunk->start, chunk->stop - 1,
|
||||
chunk->stop - chunk->start);
|
||||
CHUNKSZ(chunk));
|
||||
}
|
||||
fprintf(stderr, "Total free sectors: %llu.\n", total);
|
||||
break;
|
||||
|
|
@ -566,7 +567,7 @@ again:
|
|||
goto again;
|
||||
alloc = reallocarray(NULL, lastalloc, sizeof(struct space_allocation));
|
||||
if (alloc == NULL)
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
memcpy(alloc, alloc_table[index].table,
|
||||
lastalloc * sizeof(struct space_allocation));
|
||||
|
||||
|
|
@ -674,7 +675,7 @@ again:
|
|||
}
|
||||
free(*partmp);
|
||||
if ((*partmp = strdup(ap->mp)) == NULL)
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -788,8 +789,8 @@ editor_add(struct disklabel *lp, const char *p)
|
|||
chunk = free_chunks(lp, -1);
|
||||
new_size = new_offset = 0;
|
||||
for (; chunk->start != 0 || chunk->stop != 0; chunk++) {
|
||||
if (chunk->stop - chunk->start > new_size) {
|
||||
new_size = chunk->stop - chunk->start;
|
||||
if (CHUNKSZ(chunk) > new_size) {
|
||||
new_size = CHUNKSZ(chunk);
|
||||
new_offset = chunk->start;
|
||||
}
|
||||
}
|
||||
|
|
@ -1413,7 +1414,7 @@ editor_countfree(const struct disklabel *lp)
|
|||
chunk = free_chunks(lp, -1);
|
||||
|
||||
for (; chunk->start != 0 || chunk->stop != 0; chunk++)
|
||||
freesectors += chunk->stop - chunk->start;
|
||||
freesectors += CHUNKSZ(chunk);
|
||||
|
||||
return (freesectors);
|
||||
}
|
||||
|
|
@ -1454,7 +1455,7 @@ mpcopy(char **to, char **from)
|
|||
if (from[i] != NULL) {
|
||||
to[i] = strdup(from[i]);
|
||||
if (to[i] == NULL)
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1752,7 +1753,7 @@ get_mp(const struct disklabel *lp, int partno)
|
|||
/* XXX - might as well realloc */
|
||||
free(mountpoints[partno]);
|
||||
if ((mountpoints[partno] = strdup(p)) == NULL)
|
||||
errx(4, "out of memory");
|
||||
err(1, NULL);
|
||||
break;
|
||||
}
|
||||
fputs("Mount points must start with '/'\n", stderr);
|
||||
|
|
@ -1979,7 +1980,7 @@ parse_sizerange(char *buf, u_int64_t *min, u_int64_t *max)
|
|||
return (-1);
|
||||
if (p != NULL && p[0] != '\0') {
|
||||
if (p[0] == '*')
|
||||
*max = -1;
|
||||
*max = UINT64_MAX;
|
||||
else
|
||||
if (parse_sizespec(p, &val2, &unit2) == -1)
|
||||
return (-1);
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
# $OpenBSD: Makefile,v 1.3 1997/09/21 11:38:13 deraadt Exp $
|
||||
# $OpenBSD: Makefile,v 1.4 2023/06/19 13:05:25 deraadt Exp $
|
||||
|
||||
PROG= shutdown
|
||||
MAN= shutdown.8
|
||||
BINOWN= root
|
||||
BINGRP= operator
|
||||
BINGRP= _shutdown
|
||||
BINMODE=4550
|
||||
|
||||
.include <bsd.prog.mk>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
.\" $OpenBSD: shutdown.8,v 1.43 2023/02/04 13:03:58 jsg Exp $
|
||||
.\" $OpenBSD: shutdown.8,v 1.44 2023/06/19 13:05:25 deraadt Exp $
|
||||
.\" $NetBSD: shutdown.8,v 1.6 1995/03/18 15:01:07 cgd Exp $
|
||||
.\"
|
||||
.\" Copyright (c) 1988, 1991, 1993
|
||||
|
|
@ -30,7 +30,7 @@
|
|||
.\"
|
||||
.\" @(#)shutdown.8 8.1 (Berkeley) 6/5/93
|
||||
.\"
|
||||
.Dd $Mdocdate: February 4 2023 $
|
||||
.Dd $Mdocdate: June 19 2023 $
|
||||
.Dt SHUTDOWN 8
|
||||
.Os
|
||||
.Sh NAME
|
||||
|
|
@ -54,6 +54,15 @@ command is issued without options, the system is placed in single
|
|||
user mode at the indicated time after shutting down all system
|
||||
services.
|
||||
.Pp
|
||||
Users in the
|
||||
.Va _shutdown
|
||||
group can also run the
|
||||
.Nm
|
||||
command.
|
||||
Historically this permission was tied to the
|
||||
.Va operator
|
||||
group.
|
||||
.Pp
|
||||
The options are as follows:
|
||||
.Bl -tag -width Ds
|
||||
.It Fl d
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: agintc.c,v 1.49 2023/06/17 22:10:19 kettenis Exp $ */
|
||||
/* $OpenBSD: agintc.c,v 1.50 2023/06/18 16:25:21 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2007, 2009, 2011, 2017 Dale Rahn <drahn@dalerahn.com>
|
||||
* Copyright (c) 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
|
|
@ -843,8 +843,6 @@ agintc_enable_wakeup(void)
|
|||
cpu_dcache_wb_range((vaddr_t)&prop[irq],
|
||||
sizeof(*prop));
|
||||
__asm volatile("dsb sy");
|
||||
|
||||
/* XXX: Invalidate cache? */
|
||||
}
|
||||
|
||||
/* Invalidate cache. */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: rkclock.c,v 1.76 2023/04/27 08:55:59 kettenis Exp $ */
|
||||
/* $OpenBSD: rkclock.c,v 1.77 2023/06/19 09:54:15 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2017, 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
|
@ -4341,6 +4341,10 @@ rk3588_reset(void *cookie, uint32_t *cells, int on)
|
|||
reg = RK3588_CRU_SOFTRST_CON(33);
|
||||
bit = 1;
|
||||
break;
|
||||
case RK3588_SRST_P_PCIE4:
|
||||
reg = RK3588_CRU_SOFTRST_CON(34);
|
||||
bit = 0;
|
||||
break;
|
||||
case RK3588_SRST_REF_PIPE_PHY0:
|
||||
reg = RK3588_CRU_SOFTRST_CON(77);
|
||||
bit = 6;
|
||||
|
|
|
|||
|
|
@ -468,5 +468,6 @@
|
|||
#define RK3588_XIN24M 1023
|
||||
|
||||
#define RK3588_SRST_PCIE4_POWER_UP 298
|
||||
#define RK3588_SRST_P_PCIE4 303
|
||||
#define RK3588_SRST_REF_PIPE_PHY0 572
|
||||
#define RK3588_SRST_P_PCIE2_PHY0 579
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: rkpinctrl.c,v 1.11 2023/03/04 22:51:12 kettenis Exp $ */
|
||||
/* $OpenBSD: rkpinctrl.c,v 1.12 2023/06/19 13:37:22 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2017, 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
|
@ -1174,9 +1174,9 @@ rk3588_pinctrl(uint32_t phandle, void *cookie)
|
|||
bank = pins[i];
|
||||
idx = pins[i + 1];
|
||||
mux = pins[i + 2];
|
||||
pull = rk3568_pull(bank, idx, pins[i + 3]);
|
||||
strength = rk3568_strength(bank, idx, pins[i + 3]);
|
||||
schmitt = rk3568_schmitt(bank, idx, pins[i + 3]);
|
||||
pull = rk3588_pull(bank, idx, pins[i + 3]);
|
||||
strength = rk3588_strength(bank, idx, pins[i + 3]);
|
||||
schmitt = rk3588_schmitt(bank, idx, pins[i + 3]);
|
||||
|
||||
if (bank > 5 || idx > 32 || mux > 15)
|
||||
continue;
|
||||
|
|
@ -1237,7 +1237,7 @@ rk3588_pinctrl(uint32_t phandle, void *cookie)
|
|||
if (strength >= 0) {
|
||||
off = bank * 0x20 + (idx / 4) * 0x04;
|
||||
mask = (0xf << ((idx % 4) * 4));
|
||||
bits = ((1 << (strength + 1)) - 1) << ((idx % 4) * 4);
|
||||
bits = (strength << ((idx % 4) * 4));
|
||||
regmap_write_4(rm, ds_base + off, mask << 16 | bits);
|
||||
}
|
||||
|
||||
|
|
@ -1245,7 +1245,7 @@ rk3588_pinctrl(uint32_t phandle, void *cookie)
|
|||
if (schmitt >= 0) {
|
||||
off = bank * 0x10 + (idx / 8) * 0x04;
|
||||
mask = (0x1 << (idx % 8));
|
||||
bits = schmitt << (idx % 8);
|
||||
bits = (schmitt << (idx % 8));
|
||||
regmap_write_4(rm, smt_base + off, mask << 16 | bits);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2544,8 +2544,6 @@ static int amdgpu_device_ip_init(struct amdgpu_device *adev)
|
|||
amdgpu_fru_get_product_info(adev);
|
||||
|
||||
init_failed:
|
||||
if (amdgpu_sriov_vf(adev))
|
||||
amdgpu_virt_release_full_gpu(adev, true);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
|
@ -3593,6 +3591,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
|
|||
int r, i;
|
||||
bool px = false;
|
||||
u32 max_MBps;
|
||||
int tmp;
|
||||
|
||||
adev->shutdown = false;
|
||||
adev->flags = flags;
|
||||
|
|
@ -3774,6 +3773,12 @@ int amdgpu_device_init(struct amdgpu_device *adev,
|
|||
adev->have_atomics_support = ((struct amd_sriov_msg_pf2vf_info *)
|
||||
adev->virt.fw_reserve.p_pf2vf)->pcie_atomic_ops_support_flags ==
|
||||
(PCI_EXP_DEVCAP2_ATOMIC_COMP32 | PCI_EXP_DEVCAP2_ATOMIC_COMP64);
|
||||
/* APUs w/ gfx9 onwards doesn't reply on PCIe atomics, rather it is a
|
||||
* internal path natively support atomics, set have_atomics_support to true.
|
||||
*/
|
||||
else if ((adev->flags & AMD_IS_APU) &&
|
||||
(adev->ip_versions[GC_HWIP][0] > IP_VERSION(9, 0, 0)))
|
||||
adev->have_atomics_support = true;
|
||||
else
|
||||
adev->have_atomics_support =
|
||||
!pci_enable_atomic_ops_to_root(adev->pdev,
|
||||
|
|
@ -3782,6 +3787,13 @@ int amdgpu_device_init(struct amdgpu_device *adev,
|
|||
if (!adev->have_atomics_support)
|
||||
dev_info(adev->dev, "PCIE atomic ops is not supported\n");
|
||||
#else
|
||||
/* APUs w/ gfx9 onwards doesn't reply on PCIe atomics, rather it is a
|
||||
* internal path natively support atomics, set have_atomics_support to true.
|
||||
*/
|
||||
if ((adev->flags & AMD_IS_APU) &&
|
||||
(adev->ip_versions[GC_HWIP][0] > IP_VERSION(9, 0, 0)))
|
||||
adev->have_atomics_support = true;
|
||||
else
|
||||
adev->have_atomics_support = false;
|
||||
#endif
|
||||
|
||||
|
|
@ -3820,7 +3832,13 @@ int amdgpu_device_init(struct amdgpu_device *adev,
|
|||
}
|
||||
}
|
||||
} else {
|
||||
tmp = amdgpu_reset_method;
|
||||
/* It should do a default reset when loading or reloading the driver,
|
||||
* regardless of the module parameter reset_method.
|
||||
*/
|
||||
amdgpu_reset_method = AMD_RESET_METHOD_NONE;
|
||||
r = amdgpu_asic_reset(adev);
|
||||
amdgpu_reset_method = tmp;
|
||||
if (r) {
|
||||
dev_err(adev->dev, "asic reset on init failed\n");
|
||||
goto failed;
|
||||
|
|
@ -3880,18 +3898,6 @@ fence_driver_init:
|
|||
|
||||
r = amdgpu_device_ip_init(adev);
|
||||
if (r) {
|
||||
/* failed in exclusive mode due to timeout */
|
||||
if (amdgpu_sriov_vf(adev) &&
|
||||
!amdgpu_sriov_runtime(adev) &&
|
||||
amdgpu_virt_mmio_blocked(adev) &&
|
||||
!amdgpu_virt_wait_reset(adev)) {
|
||||
dev_err(adev->dev, "VF exclusive mode timeout\n");
|
||||
/* Don't send request since VF is inactive. */
|
||||
adev->virt.caps &= ~AMDGPU_SRIOV_CAPS_RUNTIME;
|
||||
adev->virt.ops = NULL;
|
||||
r = -EAGAIN;
|
||||
goto release_ras_con;
|
||||
}
|
||||
dev_err(adev->dev, "amdgpu_device_ip_init failed\n");
|
||||
amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_AMDGPU_INIT_FAIL, 0, 0);
|
||||
goto release_ras_con;
|
||||
|
|
@ -4000,8 +4006,10 @@ fence_driver_init:
|
|||
msecs_to_jiffies(AMDGPU_RESUME_MS));
|
||||
}
|
||||
|
||||
if (amdgpu_sriov_vf(adev))
|
||||
if (amdgpu_sriov_vf(adev)) {
|
||||
amdgpu_virt_release_full_gpu(adev, true);
|
||||
flush_delayed_work(&adev->delayed_init_work);
|
||||
}
|
||||
|
||||
r = sysfs_create_files(&adev->dev->kobj, amdgpu_dev_attributes);
|
||||
if (r)
|
||||
|
|
@ -4043,6 +4051,20 @@ fence_driver_init:
|
|||
return 0;
|
||||
|
||||
release_ras_con:
|
||||
if (amdgpu_sriov_vf(adev))
|
||||
amdgpu_virt_release_full_gpu(adev, true);
|
||||
|
||||
/* failed in exclusive mode due to timeout */
|
||||
if (amdgpu_sriov_vf(adev) &&
|
||||
!amdgpu_sriov_runtime(adev) &&
|
||||
amdgpu_virt_mmio_blocked(adev) &&
|
||||
!amdgpu_virt_wait_reset(adev)) {
|
||||
dev_err(adev->dev, "VF exclusive mode timeout\n");
|
||||
/* Don't send request since VF is inactive. */
|
||||
adev->virt.caps &= ~AMDGPU_SRIOV_CAPS_RUNTIME;
|
||||
adev->virt.ops = NULL;
|
||||
r = -EAGAIN;
|
||||
}
|
||||
amdgpu_release_ras_context(adev);
|
||||
|
||||
failed:
|
||||
|
|
|
|||
|
|
@ -545,7 +545,8 @@ void amdgpu_fence_driver_hw_fini(struct amdgpu_device *adev)
|
|||
if (r)
|
||||
amdgpu_fence_driver_force_completion(ring);
|
||||
|
||||
if (ring->fence_drv.irq_src)
|
||||
if (!drm_dev_is_unplugged(adev_to_drm(adev)) &&
|
||||
ring->fence_drv.irq_src)
|
||||
amdgpu_irq_put(adev, ring->fence_drv.irq_src,
|
||||
ring->fence_drv.irq_type);
|
||||
|
||||
|
|
|
|||
|
|
@ -526,6 +526,8 @@ void amdgpu_gmc_tmz_set(struct amdgpu_device *adev)
|
|||
case IP_VERSION(9, 3, 0):
|
||||
/* GC 10.3.7 */
|
||||
case IP_VERSION(10, 3, 7):
|
||||
/* GC 11.0.1 */
|
||||
case IP_VERSION(11, 0, 1):
|
||||
if (amdgpu_tmz == 0) {
|
||||
adev->gmc.tmz_enabled = false;
|
||||
dev_info(adev->dev,
|
||||
|
|
@ -548,7 +550,6 @@ void amdgpu_gmc_tmz_set(struct amdgpu_device *adev)
|
|||
case IP_VERSION(10, 3, 1):
|
||||
/* YELLOW_CARP*/
|
||||
case IP_VERSION(10, 3, 3):
|
||||
case IP_VERSION(11, 0, 1):
|
||||
case IP_VERSION(11, 0, 4):
|
||||
/* Don't enable it by default yet.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -2765,7 +2765,7 @@ static int dm_resume(void *handle)
|
|||
* this is the case when traversing through already created
|
||||
* MST connectors, should be skipped
|
||||
*/
|
||||
if (aconnector->dc_link->type == dc_connection_mst_branch)
|
||||
if (aconnector && aconnector->mst_port)
|
||||
continue;
|
||||
|
||||
mutex_lock(&aconnector->hpd_lock);
|
||||
|
|
@ -6494,7 +6494,7 @@ static int dm_encoder_helper_atomic_check(struct drm_encoder *encoder,
|
|||
int clock, bpp = 0;
|
||||
bool is_y420 = false;
|
||||
|
||||
if (!aconnector->port || !aconnector->dc_sink)
|
||||
if (!aconnector->port)
|
||||
return 0;
|
||||
|
||||
mst_port = aconnector->port;
|
||||
|
|
|
|||
|
|
@ -6925,23 +6925,6 @@ static int si_dpm_enable(struct amdgpu_device *adev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int si_set_temperature_range(struct amdgpu_device *adev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = si_thermal_enable_alert(adev, false);
|
||||
if (ret)
|
||||
return ret;
|
||||
ret = si_thermal_set_temperature_range(adev, R600_TEMP_RANGE_MIN, R600_TEMP_RANGE_MAX);
|
||||
if (ret)
|
||||
return ret;
|
||||
ret = si_thermal_enable_alert(adev, true);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void si_dpm_disable(struct amdgpu_device *adev)
|
||||
{
|
||||
struct rv7xx_power_info *pi = rv770_get_pi(adev);
|
||||
|
|
@ -7626,18 +7609,6 @@ static int si_dpm_process_interrupt(struct amdgpu_device *adev,
|
|||
|
||||
static int si_dpm_late_init(void *handle)
|
||||
{
|
||||
int ret;
|
||||
struct amdgpu_device *adev = (struct amdgpu_device *)handle;
|
||||
|
||||
if (!adev->pm.dpm_enabled)
|
||||
return 0;
|
||||
|
||||
ret = si_set_temperature_range(adev);
|
||||
if (ret)
|
||||
return ret;
|
||||
#if 0 //TODO ?
|
||||
si_dpm_powergate_uvd(adev, true);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -588,7 +588,7 @@ static int vangogh_print_legacy_clk_levels(struct smu_context *smu,
|
|||
DpmClocks_t *clk_table = smu->smu_table.clocks_table;
|
||||
SmuMetrics_legacy_t metrics;
|
||||
struct smu_dpm_context *smu_dpm_ctx = &(smu->smu_dpm);
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0;
|
||||
bool cur_value_match_level = false;
|
||||
|
||||
|
|
@ -662,7 +662,8 @@ static int vangogh_print_legacy_clk_levels(struct smu_context *smu,
|
|||
case SMU_MCLK:
|
||||
case SMU_FCLK:
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = vangogh_get_dpm_clk_limited(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_FCLK || clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = vangogh_get_dpm_clk_limited(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (!value)
|
||||
|
|
@ -689,7 +690,7 @@ static int vangogh_print_clk_levels(struct smu_context *smu,
|
|||
DpmClocks_t *clk_table = smu->smu_table.clocks_table;
|
||||
SmuMetrics_t metrics;
|
||||
struct smu_dpm_context *smu_dpm_ctx = &(smu->smu_dpm);
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0;
|
||||
bool cur_value_match_level = false;
|
||||
uint32_t min, max;
|
||||
|
|
@ -771,7 +772,8 @@ static int vangogh_print_clk_levels(struct smu_context *smu,
|
|||
case SMU_MCLK:
|
||||
case SMU_FCLK:
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = vangogh_get_dpm_clk_limited(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_FCLK || clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = vangogh_get_dpm_clk_limited(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (!value)
|
||||
|
|
|
|||
|
|
@ -494,7 +494,7 @@ static int renoir_set_fine_grain_gfx_freq_parameters(struct smu_context *smu)
|
|||
static int renoir_print_clk_levels(struct smu_context *smu,
|
||||
enum smu_clk_type clk_type, char *buf)
|
||||
{
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0, min = 0, max = 0;
|
||||
SmuMetrics_t metrics;
|
||||
struct smu_dpm_context *smu_dpm_ctx = &(smu->smu_dpm);
|
||||
|
|
@ -594,7 +594,8 @@ static int renoir_print_clk_levels(struct smu_context *smu,
|
|||
case SMU_VCLK:
|
||||
case SMU_DCLK:
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = renoir_get_dpm_clk_limited(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_FCLK || clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = renoir_get_dpm_clk_limited(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (!value)
|
||||
|
|
|
|||
|
|
@ -478,7 +478,7 @@ static int smu_v13_0_4_get_dpm_level_count(struct smu_context *smu,
|
|||
static int smu_v13_0_4_print_clk_levels(struct smu_context *smu,
|
||||
enum smu_clk_type clk_type, char *buf)
|
||||
{
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0;
|
||||
uint32_t min, max;
|
||||
|
||||
|
|
@ -512,7 +512,8 @@ static int smu_v13_0_4_print_clk_levels(struct smu_context *smu,
|
|||
break;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = smu_v13_0_4_get_dpm_freq_by_index(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_FCLK || clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = smu_v13_0_4_get_dpm_freq_by_index(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -866,7 +866,7 @@ out:
|
|||
static int smu_v13_0_5_print_clk_levels(struct smu_context *smu,
|
||||
enum smu_clk_type clk_type, char *buf)
|
||||
{
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0;
|
||||
uint32_t min = 0, max = 0;
|
||||
|
||||
|
|
@ -898,7 +898,8 @@ static int smu_v13_0_5_print_clk_levels(struct smu_context *smu,
|
|||
goto print_clk_out;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = smu_v13_0_5_get_dpm_freq_by_index(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = smu_v13_0_5_get_dpm_freq_by_index(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
goto print_clk_out;
|
||||
|
||||
|
|
|
|||
|
|
@ -1000,7 +1000,7 @@ out:
|
|||
static int yellow_carp_print_clk_levels(struct smu_context *smu,
|
||||
enum smu_clk_type clk_type, char *buf)
|
||||
{
|
||||
int i, size = 0, ret = 0;
|
||||
int i, idx, size = 0, ret = 0;
|
||||
uint32_t cur_value = 0, value = 0, count = 0;
|
||||
uint32_t min, max;
|
||||
|
||||
|
|
@ -1033,7 +1033,8 @@ static int yellow_carp_print_clk_levels(struct smu_context *smu,
|
|||
goto print_clk_out;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = yellow_carp_get_dpm_freq_by_index(smu, clk_type, i, &value);
|
||||
idx = (clk_type == SMU_FCLK || clk_type == SMU_MCLK) ? (count - i - 1) : i;
|
||||
ret = yellow_carp_get_dpm_freq_by_index(smu, clk_type, idx, &value);
|
||||
if (ret)
|
||||
goto print_clk_out;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_clockintr.c,v 1.22 2023/06/15 22:18:06 cheloha Exp $ */
|
||||
/* $OpenBSD: kern_clockintr.c,v 1.24 2023/06/18 23:19:01 cheloha Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2003 Dale Rahn <drahn@openbsd.org>
|
||||
* Copyright (c) 2020 Mark Kettenis <kettenis@openbsd.org>
|
||||
|
|
@ -64,6 +64,7 @@ uint64_t clockintr_nsecuptime(const struct clockintr *);
|
|||
void clockintr_schedclock(struct clockintr *, void *);
|
||||
void clockintr_schedule(struct clockintr *, uint64_t);
|
||||
void clockintr_schedule_locked(struct clockintr *, uint64_t);
|
||||
void clockintr_stagger(struct clockintr *, uint64_t, u_int, u_int);
|
||||
void clockintr_statclock(struct clockintr *, void *);
|
||||
void clockintr_statvar_init(int, uint32_t *, uint32_t *, uint32_t *);
|
||||
uint64_t clockqueue_next(const struct clockintr_queue *);
|
||||
|
|
@ -106,7 +107,7 @@ clockintr_init(u_int flags)
|
|||
void
|
||||
clockintr_cpu_init(const struct intrclock *ic)
|
||||
{
|
||||
uint64_t multiplier = 0, offset;
|
||||
uint64_t multiplier = 0;
|
||||
struct cpu_info *ci = curcpu();
|
||||
struct clockintr_queue *cq = &ci->ci_queue;
|
||||
int reset_cq_intrclock = 0;
|
||||
|
|
@ -169,8 +170,8 @@ clockintr_cpu_init(const struct intrclock *ic)
|
|||
clockintr_advance(cq->cq_hardclock, hardclock_period);
|
||||
} else {
|
||||
if (cq->cq_hardclock->cl_expiration == 0) {
|
||||
offset = hardclock_period / ncpus * multiplier;
|
||||
cq->cq_hardclock->cl_expiration = offset;
|
||||
clockintr_stagger(cq->cq_hardclock, hardclock_period,
|
||||
multiplier, ncpus);
|
||||
}
|
||||
clockintr_advance(cq->cq_hardclock, hardclock_period);
|
||||
}
|
||||
|
|
@ -178,12 +179,16 @@ clockintr_cpu_init(const struct intrclock *ic)
|
|||
/*
|
||||
* We can always advance the statclock and schedclock.
|
||||
*/
|
||||
offset = statclock_avg / ncpus * multiplier;
|
||||
clockintr_schedule(cq->cq_statclock, offset);
|
||||
if (cq->cq_statclock->cl_expiration == 0) {
|
||||
clockintr_stagger(cq->cq_statclock, statclock_avg, multiplier,
|
||||
ncpus);
|
||||
}
|
||||
clockintr_advance(cq->cq_statclock, statclock_avg);
|
||||
if (schedhz != 0) {
|
||||
offset = schedclock_period / ncpus * multiplier;
|
||||
clockintr_schedule(cq->cq_schedclock, offset);
|
||||
if (cq->cq_schedclock->cl_expiration == 0) {
|
||||
clockintr_stagger(cq->cq_schedclock, schedclock_period,
|
||||
multiplier, ncpus);
|
||||
}
|
||||
clockintr_advance(cq->cq_schedclock, schedclock_period);
|
||||
}
|
||||
|
||||
|
|
@ -459,6 +464,20 @@ clockintr_schedule_locked(struct clockintr *cl, uint64_t expiration)
|
|||
SET(cl->cl_flags, CLST_PENDING);
|
||||
}
|
||||
|
||||
void
|
||||
clockintr_stagger(struct clockintr *cl, uint64_t period, u_int n, u_int count)
|
||||
{
|
||||
struct clockintr_queue *cq = cl->cl_queue;
|
||||
|
||||
KASSERT(n < count);
|
||||
|
||||
mtx_enter(&cq->cq_mtx);
|
||||
if (ISSET(cl->cl_flags, CLST_PENDING))
|
||||
panic("%s: clock interrupt pending", __func__);
|
||||
cl->cl_expiration = period / count * n;
|
||||
mtx_leave(&cq->cq_mtx);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute the period (avg) for the given frequency and a range around
|
||||
* that period. The range is [min + 1, min + mask]. The range is used
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ca.c,v 1.44 2023/06/18 11:43:49 op Exp $ */
|
||||
/* $OpenBSD: ca.c,v 1.45 2023/06/18 19:08:52 op Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2014 Reyk Floeter <reyk@openbsd.org>
|
||||
|
|
@ -29,8 +29,6 @@
|
|||
#include "log.h"
|
||||
#include "ssl.h"
|
||||
|
||||
static int ca_verify_cb(int, X509_STORE_CTX *);
|
||||
|
||||
static int rsae_send_imsg(int, const unsigned char *, unsigned char *,
|
||||
RSA *, int, unsigned int);
|
||||
static int rsae_pub_enc(int, const unsigned char *, unsigned char *,
|
||||
|
|
@ -152,26 +150,6 @@ ca_init(void)
|
|||
}
|
||||
}
|
||||
|
||||
static int
|
||||
ca_verify_cb(int ok, X509_STORE_CTX *ctx)
|
||||
{
|
||||
switch (X509_STORE_CTX_get_error(ctx)) {
|
||||
case X509_V_OK:
|
||||
break;
|
||||
case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
|
||||
break;
|
||||
case X509_V_ERR_CERT_NOT_YET_VALID:
|
||||
case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
|
||||
break;
|
||||
case X509_V_ERR_CERT_HAS_EXPIRED:
|
||||
case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
|
||||
break;
|
||||
case X509_V_ERR_NO_EXPLICIT_POLICY:
|
||||
break;
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
int
|
||||
ca_X509_verify(void *certificate, void *chain, const char *CAfile,
|
||||
const char *CRLfile, const char **errstr)
|
||||
|
|
@ -196,8 +174,6 @@ ca_X509_verify(void *certificate, void *chain, const char *CAfile,
|
|||
if (X509_STORE_CTX_init(xsc, store, certificate, chain) != 1)
|
||||
goto end;
|
||||
|
||||
X509_STORE_CTX_set_verify_cb(xsc, ca_verify_cb);
|
||||
|
||||
ret = X509_verify_cert(xsc);
|
||||
|
||||
end:
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: smtpd.c,v 1.345 2023/05/31 16:51:46 op Exp $ */
|
||||
/* $OpenBSD: smtpd.c,v 1.346 2023/06/18 17:28:42 op Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2008 Gilles Chehade <gilles@poolp.org>
|
||||
|
|
@ -2081,19 +2081,22 @@ imsg_to_str(int type)
|
|||
|
||||
CASE(IMSG_REPORT_SMTP_LINK_CONNECT);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_DISCONNECT);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_TLS);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_GREETING);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_IDENTIFY);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_TLS);
|
||||
CASE(IMSG_REPORT_SMTP_LINK_AUTH);
|
||||
|
||||
CASE(IMSG_REPORT_SMTP_TX_RESET);
|
||||
CASE(IMSG_REPORT_SMTP_TX_BEGIN);
|
||||
CASE(IMSG_REPORT_SMTP_TX_MAIL);
|
||||
CASE(IMSG_REPORT_SMTP_TX_RCPT);
|
||||
CASE(IMSG_REPORT_SMTP_TX_ENVELOPE);
|
||||
CASE(IMSG_REPORT_SMTP_TX_DATA);
|
||||
CASE(IMSG_REPORT_SMTP_TX_COMMIT);
|
||||
CASE(IMSG_REPORT_SMTP_TX_ROLLBACK);
|
||||
|
||||
CASE(IMSG_REPORT_SMTP_PROTOCOL_CLIENT);
|
||||
CASE(IMSG_REPORT_SMTP_PROTOCOL_SERVER);
|
||||
CASE(IMSG_REPORT_SMTP_FILTER_RESPONSE);
|
||||
CASE(IMSG_REPORT_SMTP_TIMEOUT);
|
||||
|
||||
CASE(IMSG_FILTER_SMTP_BEGIN);
|
||||
CASE(IMSG_FILTER_SMTP_END);
|
||||
|
|
@ -2104,6 +2107,7 @@ imsg_to_str(int type)
|
|||
CASE(IMSG_CA_RSA_PRIVENC);
|
||||
CASE(IMSG_CA_RSA_PRIVDEC);
|
||||
CASE(IMSG_CA_ECDSA_SIGN);
|
||||
|
||||
default:
|
||||
(void)snprintf(buf, sizeof(buf), "IMSG_??? (%d)", type);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue