sync with OpenBSD -current
This commit is contained in:
parent
7d66fd8cb0
commit
3f3212838f
122 changed files with 1363 additions and 8580 deletions
|
@ -1,4 +1,4 @@
|
|||
.\" $OpenBSD: ps.1,v 1.133 2024/01/28 19:05:33 deraadt Exp $
|
||||
.\" $OpenBSD: ps.1,v 1.134 2024/02/03 18:51:57 beck Exp $
|
||||
.\" $NetBSD: ps.1,v 1.16 1996/03/21 01:36:28 jtc Exp $
|
||||
.\"
|
||||
.\" Copyright (c) 1980, 1990, 1991, 1993, 1994
|
||||
|
@ -30,7 +30,7 @@
|
|||
.\"
|
||||
.\" @(#)ps.1 8.3 (Berkeley) 4/18/94
|
||||
.\"
|
||||
.Dd $Mdocdate: January 28 2024 $
|
||||
.Dd $Mdocdate: February 3 2024 $
|
||||
.Dt PS 1
|
||||
.Os
|
||||
.Sh NAME
|
||||
|
@ -242,7 +242,6 @@ P_SUSPSINGLE 0x80000 need to suspend for single threading
|
|||
P_CONTINUED 0x800000 thread has continued after a stop
|
||||
P_THREAD 0x4000000 not the original thread
|
||||
P_SUSPSIG 0x8000000 stopped because of a signal
|
||||
P_SOFTDEP 0x10000000 stuck processing softdep worklist
|
||||
P_CPUPEG 0x40000000 do not move to another cpu
|
||||
.Ed
|
||||
.It Cm gid
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: sysctl.c,v 1.15 2023/05/22 09:29:54 kn Exp $ */
|
||||
/* $OpenBSD: sysctl.c,v 1.16 2024/02/03 16:21:20 deraadt Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2009 Theo de Raadt <deraadt@openbsd.org>
|
||||
|
@ -58,6 +58,10 @@ struct var vars[] = {
|
|||
{ CTL_HW, HW_DISKNAMES }},
|
||||
{ "hw.ncpufound", pint, 2,
|
||||
{ CTL_HW, HW_NCPUFOUND }},
|
||||
#ifdef __amd64__
|
||||
{ "machdep.retpoline", pint, 2,
|
||||
{ CTL_MACHDEP, CPU_RETPOLINE }},
|
||||
#endif
|
||||
#ifdef CPU_COMPATIBLE
|
||||
{ "machdep.compatible", pstring, 2,
|
||||
{ CTL_MACHDEP, CPU_COMPATIBLE }},
|
||||
|
|
|
@ -836,7 +836,7 @@ private:
|
|||
} // namespace
|
||||
|
||||
AArch64BtiPac::AArch64BtiPac() {
|
||||
#ifdef __OpenBSD__
|
||||
#ifdef __SecBSD__
|
||||
btiHeader = true;
|
||||
#else
|
||||
btiHeader = (config->andFeatures & GNU_PROPERTY_AARCH64_FEATURE_1_BTI);
|
||||
|
@ -941,7 +941,7 @@ void AArch64BtiPac::writePlt(uint8_t *buf, const Symbol &sym,
|
|||
}
|
||||
|
||||
static TargetInfo *getTargetInfo() {
|
||||
#ifdef __OpenBSD__
|
||||
#ifdef __SecBSD__
|
||||
static AArch64BtiPac t;
|
||||
return &t;
|
||||
#else
|
||||
|
|
|
@ -1186,6 +1186,10 @@ static TargetInfo *getTargetInfo() {
|
|||
return &t;
|
||||
}
|
||||
|
||||
#ifdef __SecBSD__
|
||||
static IntelIBT t;
|
||||
return &t;
|
||||
#else
|
||||
if (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT) {
|
||||
static IntelIBT t;
|
||||
return &t;
|
||||
|
@ -1193,6 +1197,7 @@ static TargetInfo *getTargetInfo() {
|
|||
|
||||
static X86_64 t;
|
||||
return &t;
|
||||
#endif
|
||||
}
|
||||
|
||||
TargetInfo *elf::getX86_64TargetInfo() { return getTargetInfo(); }
|
||||
|
|
|
@ -2500,6 +2500,10 @@ PltSection::PltSection()
|
|||
if ((config->emachine == EM_386 || config->emachine == EM_X86_64) &&
|
||||
(config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT))
|
||||
name = ".plt.sec";
|
||||
#ifdef __SecBSD__
|
||||
else if (config->emachine == EM_X86_64)
|
||||
name = ".plt.sec";
|
||||
#endif
|
||||
|
||||
// The PLT needs to be writable on SPARC as the dynamic linker will
|
||||
// modify the instructions in the PLT entries.
|
||||
|
|
|
@ -489,6 +489,12 @@ template <class ELFT> void elf::createSyntheticSections() {
|
|||
in.ibtPlt = std::make_unique<IBTPltSection>();
|
||||
add(*in.ibtPlt);
|
||||
}
|
||||
#ifdef __SecBSD__
|
||||
else if (config->emachine == EM_X86_64) {
|
||||
in.ibtPlt = std::make_unique<IBTPltSection>();
|
||||
add(*in.ibtPlt);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (config->emachine == EM_PPC)
|
||||
in.plt = std::make_unique<PPC32GlinkSection>();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: s3_lib.c,v 1.248 2023/11/29 13:39:34 tb Exp $ */
|
||||
/* $OpenBSD: s3_lib.c,v 1.249 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -577,41 +577,6 @@ const SSL_CIPHER ssl3_ciphers[] = {
|
|||
.alg_bits = 256,
|
||||
},
|
||||
|
||||
/* GOST Ciphersuites */
|
||||
|
||||
/* Cipher 81 */
|
||||
{
|
||||
.valid = 1,
|
||||
.name = "GOST2001-GOST89-GOST89",
|
||||
.id = 0x3000081,
|
||||
.algorithm_mkey = SSL_kGOST,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
.algorithm_enc = SSL_eGOST2814789CNT,
|
||||
.algorithm_mac = SSL_GOST89MAC,
|
||||
.algorithm_ssl = SSL_TLSV1,
|
||||
.algo_strength = SSL_HIGH,
|
||||
.algorithm2 = SSL_HANDSHAKE_MAC_GOST94|TLS1_PRF_GOST94|
|
||||
TLS1_STREAM_MAC,
|
||||
.strength_bits = 256,
|
||||
.alg_bits = 256
|
||||
},
|
||||
|
||||
/* Cipher 83 */
|
||||
{
|
||||
.valid = 1,
|
||||
.name = "GOST2001-NULL-GOST94",
|
||||
.id = 0x3000083,
|
||||
.algorithm_mkey = SSL_kGOST,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
.algorithm_enc = SSL_eNULL,
|
||||
.algorithm_mac = SSL_GOST94,
|
||||
.algorithm_ssl = SSL_TLSV1,
|
||||
.algo_strength = SSL_STRONG_NONE,
|
||||
.algorithm2 = SSL_HANDSHAKE_MAC_GOST94|TLS1_PRF_GOST94,
|
||||
.strength_bits = 0,
|
||||
.alg_bits = 0
|
||||
},
|
||||
|
||||
#ifndef OPENSSL_NO_CAMELLIA
|
||||
/* Camellia ciphersuites from RFC4132 (256-bit portion) */
|
||||
|
||||
|
@ -1362,40 +1327,6 @@ const SSL_CIPHER ssl3_ciphers[] = {
|
|||
.alg_bits = 256,
|
||||
},
|
||||
|
||||
/* Cipher FF85 FIXME IANA */
|
||||
{
|
||||
.valid = 1,
|
||||
.name = "GOST2012256-GOST89-GOST89",
|
||||
.id = 0x300ff85, /* FIXME IANA */
|
||||
.algorithm_mkey = SSL_kGOST,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
.algorithm_enc = SSL_eGOST2814789CNT,
|
||||
.algorithm_mac = SSL_GOST89MAC,
|
||||
.algorithm_ssl = SSL_TLSV1,
|
||||
.algo_strength = SSL_HIGH,
|
||||
.algorithm2 = SSL_HANDSHAKE_MAC_STREEBOG256|TLS1_PRF_STREEBOG256|
|
||||
TLS1_STREAM_MAC,
|
||||
.strength_bits = 256,
|
||||
.alg_bits = 256
|
||||
},
|
||||
|
||||
/* Cipher FF87 FIXME IANA */
|
||||
{
|
||||
.valid = 1,
|
||||
.name = "GOST2012256-NULL-STREEBOG256",
|
||||
.id = 0x300ff87, /* FIXME IANA */
|
||||
.algorithm_mkey = SSL_kGOST,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
.algorithm_enc = SSL_eNULL,
|
||||
.algorithm_mac = SSL_STREEBOG256,
|
||||
.algorithm_ssl = SSL_TLSV1,
|
||||
.algo_strength = SSL_STRONG_NONE,
|
||||
.algorithm2 = SSL_HANDSHAKE_MAC_STREEBOG256|TLS1_PRF_STREEBOG256,
|
||||
.strength_bits = 0,
|
||||
.alg_bits = 0
|
||||
},
|
||||
|
||||
|
||||
/* end of list */
|
||||
};
|
||||
|
||||
|
@ -2668,21 +2599,6 @@ ssl3_get_req_cert_types(SSL *s, CBB *cbb)
|
|||
|
||||
alg_k = s->s3->hs.cipher->algorithm_mkey;
|
||||
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
if ((alg_k & SSL_kGOST) != 0) {
|
||||
if (!CBB_add_u8(cbb, TLS_CT_GOST01_SIGN))
|
||||
return 0;
|
||||
if (!CBB_add_u8(cbb, TLS_CT_GOST12_256_SIGN))
|
||||
return 0;
|
||||
if (!CBB_add_u8(cbb, TLS_CT_GOST12_512_SIGN))
|
||||
return 0;
|
||||
if (!CBB_add_u8(cbb, TLS_CT_GOST12_256_SIGN_COMPAT))
|
||||
return 0;
|
||||
if (!CBB_add_u8(cbb, TLS_CT_GOST12_512_SIGN_COMPAT))
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((alg_k & SSL_kDHE) != 0) {
|
||||
if (!CBB_add_u8(cbb, SSL3_CT_RSA_FIXED_DH))
|
||||
return 0;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl.h,v 1.232 2023/11/22 15:43:42 tb Exp $ */
|
||||
/* $OpenBSD: ssl.h,v 1.233 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -245,7 +245,6 @@ extern "C" {
|
|||
#define SSL_TXT_kECDH "kECDH"
|
||||
#define SSL_TXT_kEECDH "kEECDH"
|
||||
#define SSL_TXT_kPSK "kPSK"
|
||||
#define SSL_TXT_kGOST "kGOST"
|
||||
#define SSL_TXT_kSRP "kSRP"
|
||||
|
||||
#define SSL_TXT_aRSA "aRSA"
|
||||
|
@ -255,9 +254,6 @@ extern "C" {
|
|||
#define SSL_TXT_aKRB5 "aKRB5"
|
||||
#define SSL_TXT_aECDSA "aECDSA"
|
||||
#define SSL_TXT_aPSK "aPSK"
|
||||
#define SSL_TXT_aGOST94 "aGOST94"
|
||||
#define SSL_TXT_aGOST01 "aGOST01"
|
||||
#define SSL_TXT_aGOST "aGOST"
|
||||
|
||||
#define SSL_TXT_DSS "DSS"
|
||||
#define SSL_TXT_DH "DH"
|
||||
|
@ -293,12 +289,8 @@ extern "C" {
|
|||
#define SSL_TXT_MD5 "MD5"
|
||||
#define SSL_TXT_SHA1 "SHA1"
|
||||
#define SSL_TXT_SHA "SHA" /* same as "SHA1" */
|
||||
#define SSL_TXT_GOST94 "GOST94"
|
||||
#define SSL_TXT_GOST89MAC "GOST89MAC"
|
||||
#define SSL_TXT_SHA256 "SHA256"
|
||||
#define SSL_TXT_SHA384 "SHA384"
|
||||
#define SSL_TXT_STREEBOG256 "STREEBOG256"
|
||||
#define SSL_TXT_STREEBOG512 "STREEBOG512"
|
||||
|
||||
#define SSL_TXT_DTLS1 "DTLSv1"
|
||||
#define SSL_TXT_DTLS1_2 "DTLSv1.2"
|
||||
|
@ -2176,7 +2168,6 @@ void ERR_load_SSL_strings(void);
|
|||
#define SSL_R_NO_CLIENT_CERT_METHOD 331
|
||||
#define SSL_R_NO_CLIENT_CERT_RECEIVED 186
|
||||
#define SSL_R_NO_COMPRESSION_SPECIFIED 187
|
||||
#define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER 330
|
||||
#define SSL_R_NO_METHOD_SPECIFIED 188
|
||||
#define SSL_R_NO_PRIVATEKEY 189
|
||||
#define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl3.h,v 1.57 2021/09/10 14:49:13 tb Exp $ */
|
||||
/* $OpenBSD: ssl3.h,v 1.58 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -325,7 +325,7 @@ extern "C" {
|
|||
* enough to contain all of the cert types defined either for
|
||||
* SSLv3 and TLSv1.
|
||||
*/
|
||||
#define SSL3_CT_NUMBER 13
|
||||
#define SSL3_CT_NUMBER 7
|
||||
|
||||
#define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001
|
||||
#define TLS1_FLAGS_SKIP_CERT_VERIFY 0x0010
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_both.c,v 1.46 2023/07/07 08:53:55 tb Exp $ */
|
||||
/* $OpenBSD: ssl_both.c,v 1.47 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -384,9 +384,6 @@ ssl_cert_type(EVP_PKEY *pkey)
|
|||
switch (EVP_PKEY_id(pkey)) {
|
||||
case EVP_PKEY_EC:
|
||||
return SSL_PKEY_ECC;
|
||||
case NID_id_GostR3410_2001:
|
||||
case NID_id_GostR3410_2001_cc:
|
||||
return SSL_PKEY_GOST01;
|
||||
case EVP_PKEY_RSA:
|
||||
case EVP_PKEY_RSA_PSS:
|
||||
return SSL_PKEY_RSA;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_cert.c,v 1.107 2023/07/08 16:40:13 beck Exp $ */
|
||||
/* $OpenBSD: ssl_cert.c,v 1.108 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -233,10 +233,6 @@ ssl_cert_dup(SSL_CERT *cert)
|
|||
/* We have an ECC key */
|
||||
break;
|
||||
|
||||
case SSL_PKEY_GOST01:
|
||||
/* We have a GOST key */
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Can't happen. */
|
||||
SSLerrorx(SSL_R_LIBRARY_BUG);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_ciph.c,v 1.138 2024/01/04 20:02:10 tb Exp $ */
|
||||
/* $OpenBSD: ssl_ciph.c,v 1.139 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -212,10 +212,6 @@ static const SSL_CIPHER cipher_aliases[] = {
|
|||
.name = SSL_TXT_ECDH,
|
||||
.algorithm_mkey = SSL_kECDHE,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_kGOST,
|
||||
.algorithm_mkey = SSL_kGOST,
|
||||
},
|
||||
|
||||
/* server authentication aliases */
|
||||
{
|
||||
|
@ -242,14 +238,6 @@ static const SSL_CIPHER cipher_aliases[] = {
|
|||
.name = SSL_TXT_ECDSA,
|
||||
.algorithm_auth = SSL_aECDSA,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_aGOST01,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_aGOST,
|
||||
.algorithm_auth = SSL_aGOST01,
|
||||
},
|
||||
|
||||
/* aliases combining key exchange and server authentication */
|
||||
{
|
||||
|
@ -355,14 +343,6 @@ static const SSL_CIPHER cipher_aliases[] = {
|
|||
.name = SSL_TXT_SHA,
|
||||
.algorithm_mac = SSL_SHA1,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_GOST94,
|
||||
.algorithm_mac = SSL_GOST94,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_GOST89MAC,
|
||||
.algorithm_mac = SSL_GOST89MAC,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_SHA256,
|
||||
.algorithm_mac = SSL_SHA256,
|
||||
|
@ -371,10 +351,6 @@ static const SSL_CIPHER cipher_aliases[] = {
|
|||
.name = SSL_TXT_SHA384,
|
||||
.algorithm_mac = SSL_SHA384,
|
||||
},
|
||||
{
|
||||
.name = SSL_TXT_STREEBOG256,
|
||||
.algorithm_mac = SSL_STREEBOG256,
|
||||
},
|
||||
|
||||
/* protocol version aliases */
|
||||
{
|
||||
|
@ -472,11 +448,6 @@ ssl_cipher_get_evp(const SSL_SESSION *ss, const EVP_CIPHER **enc,
|
|||
case SSL_CAMELLIA256:
|
||||
*enc = EVP_camellia_256_cbc();
|
||||
break;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
case SSL_eGOST2814789CNT:
|
||||
*enc = EVP_gost2814789_cnt();
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
switch (ss->cipher->algorithm_mac) {
|
||||
|
@ -492,21 +463,11 @@ ssl_cipher_get_evp(const SSL_SESSION *ss, const EVP_CIPHER **enc,
|
|||
case SSL_SHA384:
|
||||
*md = EVP_sha384();
|
||||
break;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
case SSL_GOST89MAC:
|
||||
*md = EVP_gost2814789imit();
|
||||
break;
|
||||
case SSL_GOST94:
|
||||
*md = EVP_gostr341194();
|
||||
break;
|
||||
case SSL_STREEBOG256:
|
||||
*md = EVP_streebog256();
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
if (*enc == NULL || *md == NULL)
|
||||
return 0;
|
||||
|
||||
/* XXX remove these from ssl_cipher_get_evp? */
|
||||
/*
|
||||
* EVP_CIPH_FLAG_AEAD_CIPHER and EVP_CIPH_GCM_MODE ciphers are not
|
||||
* supported via EVP_CIPHER (they should be using EVP_AEAD instead).
|
||||
|
@ -515,18 +476,9 @@ ssl_cipher_get_evp(const SSL_SESSION *ss, const EVP_CIPHER **enc,
|
|||
return 0;
|
||||
if (EVP_CIPHER_mode(*enc) == EVP_CIPH_GCM_MODE)
|
||||
return 0;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
/* XXX JFC. die in fire already */
|
||||
if (ss->cipher->algorithm_mac == SSL_GOST89MAC) {
|
||||
*mac_pkey_type = EVP_PKEY_GOSTIMIT;
|
||||
*mac_secret_size = 32; /* XXX */
|
||||
} else {
|
||||
#endif
|
||||
*mac_pkey_type = EVP_PKEY_HMAC;
|
||||
*mac_secret_size = EVP_MD_size(*md);
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
}
|
||||
#endif
|
||||
|
||||
*mac_pkey_type = EVP_PKEY_HMAC;
|
||||
*mac_secret_size = EVP_MD_size(*md);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -581,14 +533,6 @@ ssl_get_handshake_evp_md(SSL *s, const EVP_MD **md)
|
|||
case SSL_HANDSHAKE_MAC_DEFAULT:
|
||||
*md = EVP_md5_sha1();
|
||||
return 1;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
case SSL_HANDSHAKE_MAC_GOST94:
|
||||
*md = EVP_gostr341194();
|
||||
return 1;
|
||||
case SSL_HANDSHAKE_MAC_STREEBOG256:
|
||||
*md = EVP_streebog256();
|
||||
return 1;
|
||||
#endif
|
||||
case SSL_HANDSHAKE_MAC_SHA256:
|
||||
*md = EVP_sha256();
|
||||
return 1;
|
||||
|
@ -641,6 +585,7 @@ ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr,
|
|||
*head = curr;
|
||||
}
|
||||
|
||||
/* XXX beck: remove this in a followon to removing GOST */
|
||||
static void
|
||||
ssl_cipher_get_disabled(unsigned long *mkey, unsigned long *auth,
|
||||
unsigned long *enc, unsigned long *mac, unsigned long *ssl)
|
||||
|
@ -651,16 +596,6 @@ ssl_cipher_get_disabled(unsigned long *mkey, unsigned long *auth,
|
|||
*mac = 0;
|
||||
*ssl = 0;
|
||||
|
||||
/*
|
||||
* Check for the availability of GOST 34.10 public/private key
|
||||
* algorithms. If they are not available disable the associated
|
||||
* authentication and key exchange algorithms.
|
||||
*/
|
||||
#if defined(OPENSSL_NO_GOST) || !defined(EVP_PKEY_GOSTR01)
|
||||
*auth |= SSL_aGOST01;
|
||||
*mkey |= SSL_kGOST;
|
||||
#endif
|
||||
|
||||
#ifdef SSL_FORBID_ENULL
|
||||
*enc |= SSL_eNULL;
|
||||
#endif
|
||||
|
@ -1455,9 +1390,6 @@ SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
|
|||
case SSL_kECDHE:
|
||||
kx = "ECDH";
|
||||
break;
|
||||
case SSL_kGOST:
|
||||
kx = "GOST";
|
||||
break;
|
||||
case SSL_kTLS1_3:
|
||||
kx = "TLSv1.3";
|
||||
break;
|
||||
|
@ -1478,9 +1410,6 @@ SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
|
|||
case SSL_aECDSA:
|
||||
au = "ECDSA";
|
||||
break;
|
||||
case SSL_aGOST01:
|
||||
au = "GOST01";
|
||||
break;
|
||||
case SSL_aTLS1_3:
|
||||
au = "TLSv1.3";
|
||||
break;
|
||||
|
@ -1520,9 +1449,6 @@ SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
|
|||
case SSL_CHACHA20POLY1305:
|
||||
enc = "ChaCha20-Poly1305";
|
||||
break;
|
||||
case SSL_eGOST2814789CNT:
|
||||
enc = "GOST-28178-89-CNT";
|
||||
break;
|
||||
default:
|
||||
enc = "unknown";
|
||||
break;
|
||||
|
@ -1544,15 +1470,6 @@ SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
|
|||
case SSL_AEAD:
|
||||
mac = "AEAD";
|
||||
break;
|
||||
case SSL_GOST94:
|
||||
mac = "GOST94";
|
||||
break;
|
||||
case SSL_GOST89MAC:
|
||||
mac = "GOST89IMIT";
|
||||
break;
|
||||
case SSL_STREEBOG256:
|
||||
mac = "STREEBOG256";
|
||||
break;
|
||||
default:
|
||||
mac = "unknown";
|
||||
break;
|
||||
|
@ -1666,8 +1583,6 @@ SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c)
|
|||
return NID_des_cbc;
|
||||
case SSL_RC4:
|
||||
return NID_rc4;
|
||||
case SSL_eGOST2814789CNT:
|
||||
return NID_gost89_cnt;
|
||||
default:
|
||||
return NID_undef;
|
||||
}
|
||||
|
@ -1680,10 +1595,6 @@ SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c)
|
|||
switch (c->algorithm_mac) {
|
||||
case SSL_AEAD:
|
||||
return NID_undef;
|
||||
case SSL_GOST89MAC:
|
||||
return NID_id_Gost28147_89_MAC;
|
||||
case SSL_GOST94:
|
||||
return NID_id_GostR3411_94;
|
||||
case SSL_MD5:
|
||||
return NID_md5;
|
||||
case SSL_SHA1:
|
||||
|
@ -1692,8 +1603,6 @@ SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c)
|
|||
return NID_sha256;
|
||||
case SSL_SHA384:
|
||||
return NID_sha384;
|
||||
case SSL_STREEBOG256:
|
||||
return NID_id_tc26_gost3411_2012_256;
|
||||
default:
|
||||
return NID_undef;
|
||||
}
|
||||
|
@ -1708,8 +1617,6 @@ SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c)
|
|||
return NID_kx_dhe;
|
||||
case SSL_kECDHE:
|
||||
return NID_kx_ecdhe;
|
||||
case SSL_kGOST:
|
||||
return NID_kx_gost;
|
||||
case SSL_kRSA:
|
||||
return NID_kx_rsa;
|
||||
default:
|
||||
|
@ -1726,8 +1633,6 @@ SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c)
|
|||
return NID_auth_null;
|
||||
case SSL_aECDSA:
|
||||
return NID_auth_ecdsa;
|
||||
case SSL_aGOST01:
|
||||
return NID_auth_gost01;
|
||||
case SSL_aRSA:
|
||||
return NID_auth_rsa;
|
||||
default:
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_clnt.c,v 1.163 2023/12/29 12:24:33 tb Exp $ */
|
||||
/* $OpenBSD: ssl_clnt.c,v 1.165 2024/02/03 18:03:49 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -161,10 +161,6 @@
|
|||
#include <openssl/objects.h>
|
||||
#include <openssl/opensslconf.h>
|
||||
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
#include <openssl/gost.h>
|
||||
#endif
|
||||
|
||||
#include "bytestring.h"
|
||||
#include "dtls_local.h"
|
||||
#include "ssl_local.h"
|
||||
|
@ -459,12 +455,6 @@ ssl3_connect(SSL *s)
|
|||
s->s3->hs.state = SSL3_ST_CW_CHANGE_A;
|
||||
s->s3->change_cipher_spec = 0;
|
||||
}
|
||||
if (!SSL_is_dtls(s)) {
|
||||
if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
|
||||
s->s3->hs.state = SSL3_ST_CW_CHANGE_A;
|
||||
s->s3->change_cipher_spec = 0;
|
||||
}
|
||||
}
|
||||
|
||||
s->init_num = 0;
|
||||
break;
|
||||
|
@ -829,7 +819,6 @@ ssl3_get_server_hello(SSL *s)
|
|||
uint8_t compression_method;
|
||||
const SSL_CIPHER *cipher;
|
||||
const SSL_METHOD *method;
|
||||
unsigned long alg_k;
|
||||
int al, ret;
|
||||
|
||||
s->first_packet = 1;
|
||||
|
@ -1038,8 +1027,7 @@ ssl3_get_server_hello(SSL *s)
|
|||
* Don't digest cached records if no sigalgs: we may need them for
|
||||
* client authentication.
|
||||
*/
|
||||
alg_k = s->s3->hs.cipher->algorithm_mkey;
|
||||
if (!(SSL_USE_SIGALGS(s) || (alg_k & SSL_kGOST)))
|
||||
if (!SSL_USE_SIGALGS(s))
|
||||
tls1_transcript_free(s);
|
||||
|
||||
if (!CBS_get_u8(&cbs, &compression_method))
|
||||
|
@ -1930,119 +1918,6 @@ ssl3_send_client_kex_ecdhe(SSL *s, CBB *cbb)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
ssl3_send_client_kex_gost(SSL *s, CBB *cbb)
|
||||
{
|
||||
unsigned char premaster_secret[32], shared_ukm[32], tmp[256];
|
||||
EVP_PKEY_CTX *pkey_ctx = NULL;
|
||||
EVP_MD_CTX *ukm_hash = NULL;
|
||||
EVP_PKEY *pkey;
|
||||
size_t msglen;
|
||||
unsigned int md_len;
|
||||
CBB gostblob;
|
||||
int nid;
|
||||
int ret = 0;
|
||||
|
||||
/* Get server certificate PKEY and create ctx from it */
|
||||
pkey = X509_get0_pubkey(s->session->peer_cert);
|
||||
if (pkey == NULL || s->session->peer_cert_type != SSL_PKEY_GOST01) {
|
||||
SSLerror(s, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
|
||||
goto err;
|
||||
}
|
||||
if ((pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL)) == NULL) {
|
||||
SSLerror(s, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we have send a certificate, and certificate key parameters match
|
||||
* those of server certificate, use certificate key for key exchange.
|
||||
* Otherwise, generate ephemeral key pair.
|
||||
*/
|
||||
if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0)
|
||||
goto err;
|
||||
|
||||
/* Generate session key. */
|
||||
arc4random_buf(premaster_secret, sizeof(premaster_secret));
|
||||
|
||||
/*
|
||||
* If we have client certificate, use its secret as peer key.
|
||||
* XXX - this presumably lacks PFS.
|
||||
*/
|
||||
if (s->s3->hs.tls12.cert_request != 0 &&
|
||||
s->cert->key->privatekey != NULL) {
|
||||
if (EVP_PKEY_derive_set_peer(pkey_ctx,
|
||||
s->cert->key->privatekey) <=0) {
|
||||
/*
|
||||
* If there was an error - just ignore it.
|
||||
* Ephemeral key would be used.
|
||||
*/
|
||||
ERR_clear_error();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute shared IV and store it in algorithm-specific context data.
|
||||
*/
|
||||
if ((ukm_hash = EVP_MD_CTX_new()) == NULL) {
|
||||
SSLerror(s, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* XXX check handshake hash instead. */
|
||||
if (s->s3->hs.cipher->algorithm2 & SSL_HANDSHAKE_MAC_GOST94)
|
||||
nid = NID_id_GostR3411_94;
|
||||
else
|
||||
nid = NID_id_tc26_gost3411_2012_256;
|
||||
if (!EVP_DigestInit(ukm_hash, EVP_get_digestbynid(nid)))
|
||||
goto err;
|
||||
if (!EVP_DigestUpdate(ukm_hash, s->s3->client_random, SSL3_RANDOM_SIZE))
|
||||
goto err;
|
||||
if (!EVP_DigestUpdate(ukm_hash, s->s3->server_random, SSL3_RANDOM_SIZE))
|
||||
goto err;
|
||||
if (!EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len))
|
||||
goto err;
|
||||
if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
|
||||
EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) < 0) {
|
||||
SSLerror(s, SSL_R_LIBRARY_BUG);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Make GOST keytransport blob message, encapsulate it into sequence.
|
||||
*/
|
||||
msglen = 255;
|
||||
if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, premaster_secret,
|
||||
sizeof(premaster_secret)) < 0) {
|
||||
SSLerror(s, SSL_R_LIBRARY_BUG);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!CBB_add_asn1(cbb, &gostblob, CBS_ASN1_SEQUENCE))
|
||||
goto err;
|
||||
if (!CBB_add_bytes(&gostblob, tmp, msglen))
|
||||
goto err;
|
||||
if (!CBB_flush(cbb))
|
||||
goto err;
|
||||
|
||||
/* Check if pubkey from client certificate was used. */
|
||||
if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2,
|
||||
NULL) > 0)
|
||||
s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
|
||||
|
||||
if (!tls12_derive_master_secret(s, premaster_secret, 32))
|
||||
goto err;
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
explicit_bzero(premaster_secret, sizeof(premaster_secret));
|
||||
EVP_PKEY_CTX_free(pkey_ctx);
|
||||
EVP_MD_CTX_free(ukm_hash);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
ssl3_send_client_key_exchange(SSL *s)
|
||||
{
|
||||
|
@ -2067,9 +1942,6 @@ ssl3_send_client_key_exchange(SSL *s)
|
|||
} else if (alg_k & SSL_kECDHE) {
|
||||
if (!ssl3_send_client_kex_ecdhe(s, &kex))
|
||||
goto err;
|
||||
} else if (alg_k & SSL_kGOST) {
|
||||
if (!ssl3_send_client_kex_gost(s, &kex))
|
||||
goto err;
|
||||
} else {
|
||||
ssl3_send_alert(s, SSL3_AL_FATAL,
|
||||
SSL_AD_HANDSHAKE_FAILURE);
|
||||
|
@ -2115,14 +1987,6 @@ ssl3_send_client_verify_sigalgs(SSL *s, EVP_PKEY *pkey,
|
|||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
if (sigalg->key_type == EVP_PKEY_GOSTR01 &&
|
||||
EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
|
||||
EVP_PKEY_CTRL_GOST_SIG_FORMAT, GOST_SIG_FORMAT_RS_LE, NULL) <= 0) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
#endif
|
||||
if ((sigalg->flags & SIGALG_FLAG_RSA_PSS) &&
|
||||
(!EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) ||
|
||||
!EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, -1))) {
|
||||
|
@ -2230,72 +2094,6 @@ ssl3_send_client_verify_ec(SSL *s, EVP_PKEY *pkey, CBB *cert_verify)
|
|||
return ret;
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
static int
|
||||
ssl3_send_client_verify_gost(SSL *s, EVP_PKEY *pkey, CBB *cert_verify)
|
||||
{
|
||||
CBB cbb_signature;
|
||||
EVP_MD_CTX *mctx;
|
||||
EVP_PKEY_CTX *pctx;
|
||||
const EVP_MD *md;
|
||||
const unsigned char *hdata;
|
||||
unsigned char *signature = NULL;
|
||||
size_t signature_len;
|
||||
size_t hdata_len;
|
||||
int nid;
|
||||
int ret = 0;
|
||||
|
||||
if ((mctx = EVP_MD_CTX_new()) == NULL)
|
||||
goto err;
|
||||
|
||||
if (!tls1_transcript_data(s, &hdata, &hdata_len)) {
|
||||
SSLerror(s, ERR_R_INTERNAL_ERROR);
|
||||
goto err;
|
||||
}
|
||||
if (!EVP_PKEY_get_default_digest_nid(pkey, &nid) ||
|
||||
(md = EVP_get_digestbynid(nid)) == NULL) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
if (!EVP_DigestSignInit(mctx, &pctx, md, NULL, pkey)) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_SIGN,
|
||||
EVP_PKEY_CTRL_GOST_SIG_FORMAT, GOST_SIG_FORMAT_RS_LE, NULL) <= 0) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
#endif
|
||||
if (!EVP_DigestSign(mctx, NULL, &signature_len, hdata, hdata_len)) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
if ((signature = calloc(1, signature_len)) == NULL) {
|
||||
SSLerror(s, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
if (!EVP_DigestSign(mctx, signature, &signature_len, hdata, hdata_len)) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!CBB_add_u16_length_prefixed(cert_verify, &cbb_signature))
|
||||
goto err;
|
||||
if (!CBB_add_bytes(&cbb_signature, signature, signature_len))
|
||||
goto err;
|
||||
if (!CBB_flush(cert_verify))
|
||||
goto err;
|
||||
|
||||
ret = 1;
|
||||
err:
|
||||
EVP_MD_CTX_free(mctx);
|
||||
free(signature);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int
|
||||
ssl3_send_client_verify(SSL *s)
|
||||
{
|
||||
|
@ -2331,12 +2129,6 @@ ssl3_send_client_verify(SSL *s)
|
|||
} else if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
|
||||
if (!ssl3_send_client_verify_ec(s, pkey, &cert_verify))
|
||||
goto err;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
} else if (EVP_PKEY_id(pkey) == NID_id_GostR3410_94 ||
|
||||
EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
|
||||
if (!ssl3_send_client_verify_gost(s, pkey, &cert_verify))
|
||||
goto err;
|
||||
#endif
|
||||
} else {
|
||||
SSLerror(s, ERR_R_INTERNAL_ERROR);
|
||||
goto err;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_err.c,v 1.46 2023/07/08 16:40:13 beck Exp $ */
|
||||
/* $OpenBSD: ssl_err.c,v 1.47 2024/02/03 15:58:33 beck Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
@ -306,7 +306,6 @@ static ERR_STRING_DATA SSL_str_reasons[]= {
|
|||
{ERR_REASON(SSL_R_NO_CLIENT_CERT_METHOD) , "no client cert method"},
|
||||
{ERR_REASON(SSL_R_NO_CLIENT_CERT_RECEIVED), "no client cert received"},
|
||||
{ERR_REASON(SSL_R_NO_COMPRESSION_SPECIFIED), "no compression specified"},
|
||||
{ERR_REASON(SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER), "Peer haven't sent GOST certificate, required for selected ciphersuite"},
|
||||
{ERR_REASON(SSL_R_NO_METHOD_SPECIFIED) , "no method specified"},
|
||||
{ERR_REASON(SSL_R_NO_PRIVATEKEY) , "no privatekey"},
|
||||
{ERR_REASON(SSL_R_NO_PRIVATE_KEY_ASSIGNED), "no private key assigned"},
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_lib.c,v 1.318 2023/12/29 12:24:33 tb Exp $ */
|
||||
/* $OpenBSD: ssl_lib.c,v 1.319 2024/02/03 15:58:34 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -2297,12 +2297,6 @@ ssl_set_cert_masks(SSL_CERT *c, const SSL_CIPHER *cipher)
|
|||
mask_a |= SSL_aECDSA;
|
||||
}
|
||||
|
||||
cpk = &(c->pkeys[SSL_PKEY_GOST01]);
|
||||
if (cpk->x509 != NULL && cpk->privatekey != NULL) {
|
||||
mask_k |= SSL_kGOST;
|
||||
mask_a |= SSL_aGOST01;
|
||||
}
|
||||
|
||||
cpk = &(c->pkeys[SSL_PKEY_RSA]);
|
||||
if (cpk->x509 != NULL && cpk->privatekey != NULL) {
|
||||
mask_a |= SSL_aRSA;
|
||||
|
@ -2363,8 +2357,6 @@ ssl_get_server_send_pkey(const SSL *s)
|
|||
i = SSL_PKEY_ECC;
|
||||
} else if (alg_a & SSL_aRSA) {
|
||||
i = SSL_PKEY_RSA;
|
||||
} else if (alg_a & SSL_aGOST01) {
|
||||
i = SSL_PKEY_GOST01;
|
||||
} else { /* if (alg_a & SSL_aNULL) */
|
||||
SSLerror(s, ERR_R_INTERNAL_ERROR);
|
||||
return (NULL);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_local.h,v 1.12 2023/12/29 12:24:33 tb Exp $ */
|
||||
/* $OpenBSD: ssl_local.h,v 1.13 2024/02/03 15:58:34 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -197,7 +197,6 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define SSL_kRSA 0x00000001L /* RSA key exchange */
|
||||
#define SSL_kDHE 0x00000008L /* tmp DH key no DH cert */
|
||||
#define SSL_kECDHE 0x00000080L /* ephemeral ECDH */
|
||||
#define SSL_kGOST 0x00000200L /* GOST key exchange */
|
||||
#define SSL_kTLS1_3 0x00000400L /* TLSv1.3 key exchange */
|
||||
|
||||
/* Bits for algorithm_auth (server authentication) */
|
||||
|
@ -205,7 +204,6 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define SSL_aDSS 0x00000002L /* DSS auth */
|
||||
#define SSL_aNULL 0x00000004L /* no auth (i.e. use ADH or AECDH) */
|
||||
#define SSL_aECDSA 0x00000040L /* ECDSA auth*/
|
||||
#define SSL_aGOST01 0x00000200L /* GOST R 34.10-2001 signature auth */
|
||||
#define SSL_aTLS1_3 0x00000400L /* TLSv1.3 authentication */
|
||||
|
||||
/* Bits for algorithm_enc (symmetric encryption) */
|
||||
|
@ -218,7 +216,6 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define SSL_AES256 0x00000040L
|
||||
#define SSL_CAMELLIA128 0x00000080L
|
||||
#define SSL_CAMELLIA256 0x00000100L
|
||||
#define SSL_eGOST2814789CNT 0x00000200L
|
||||
#define SSL_AES128GCM 0x00000400L
|
||||
#define SSL_AES256GCM 0x00000800L
|
||||
#define SSL_CHACHA20POLY1305 0x00001000L
|
||||
|
@ -231,8 +228,6 @@ __BEGIN_HIDDEN_DECLS
|
|||
|
||||
#define SSL_MD5 0x00000001L
|
||||
#define SSL_SHA1 0x00000002L
|
||||
#define SSL_GOST94 0x00000004L
|
||||
#define SSL_GOST89MAC 0x00000008L
|
||||
#define SSL_SHA256 0x00000010L
|
||||
#define SSL_SHA384 0x00000020L
|
||||
/* Not a real MAC, just an indication it is part of cipher */
|
||||
|
@ -251,10 +246,8 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define SSL_HANDSHAKE_MAC_MASK 0xff0
|
||||
#define SSL_HANDSHAKE_MAC_MD5 0x010
|
||||
#define SSL_HANDSHAKE_MAC_SHA 0x020
|
||||
#define SSL_HANDSHAKE_MAC_GOST94 0x040
|
||||
#define SSL_HANDSHAKE_MAC_SHA256 0x080
|
||||
#define SSL_HANDSHAKE_MAC_SHA384 0x100
|
||||
#define SSL_HANDSHAKE_MAC_STREEBOG256 0x200
|
||||
#define SSL_HANDSHAKE_MAC_DEFAULT (SSL_HANDSHAKE_MAC_MD5 | SSL_HANDSHAKE_MAC_SHA)
|
||||
|
||||
#define SSL3_CK_ID 0x03000000
|
||||
|
@ -267,16 +260,8 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define TLS1_PRF_SHA1 (SSL_HANDSHAKE_MAC_SHA << TLS1_PRF_DGST_SHIFT)
|
||||
#define TLS1_PRF_SHA256 (SSL_HANDSHAKE_MAC_SHA256 << TLS1_PRF_DGST_SHIFT)
|
||||
#define TLS1_PRF_SHA384 (SSL_HANDSHAKE_MAC_SHA384 << TLS1_PRF_DGST_SHIFT)
|
||||
#define TLS1_PRF_GOST94 (SSL_HANDSHAKE_MAC_GOST94 << TLS1_PRF_DGST_SHIFT)
|
||||
#define TLS1_PRF_STREEBOG256 (SSL_HANDSHAKE_MAC_STREEBOG256 << TLS1_PRF_DGST_SHIFT)
|
||||
#define TLS1_PRF (TLS1_PRF_MD5 | TLS1_PRF_SHA1)
|
||||
|
||||
/*
|
||||
* Stream MAC for GOST ciphersuites from cryptopro draft
|
||||
* (currently this also goes into algorithm2).
|
||||
*/
|
||||
#define TLS1_STREAM_MAC 0x04
|
||||
|
||||
/*
|
||||
* SSL_CIPHER_ALGORITHM2_VARIABLE_NONCE_IN_RECORD is an algorithm2 flag that
|
||||
* indicates that the variable part of the nonce is included as a prefix of
|
||||
|
@ -324,8 +309,7 @@ __BEGIN_HIDDEN_DECLS
|
|||
|
||||
#define SSL_PKEY_RSA 0
|
||||
#define SSL_PKEY_ECC 1
|
||||
#define SSL_PKEY_GOST01 2
|
||||
#define SSL_PKEY_NUM 3
|
||||
#define SSL_PKEY_NUM 2
|
||||
|
||||
#define SSL_MAX_EMPTY_RECORDS 32
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_sigalgs.c,v 1.48 2022/11/26 16:08:56 tb Exp $ */
|
||||
/* $OpenBSD: ssl_sigalgs.c,v 1.49 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Bob Beck <beck@openbsd.org>
|
||||
* Copyright (c) 2021 Joel Sing <jsing@openbsd.org>
|
||||
|
@ -41,14 +41,6 @@ const struct ssl_sigalg sigalgs[] = {
|
|||
.security_level = 5,
|
||||
.group_nid = NID_secp521r1,
|
||||
},
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
{
|
||||
.value = SIGALG_GOSTR12_512_STREEBOG_512,
|
||||
.key_type = EVP_PKEY_GOSTR12_512,
|
||||
.md = EVP_streebog512,
|
||||
.security_level = 0,
|
||||
},
|
||||
#endif
|
||||
{
|
||||
.value = SIGALG_RSA_PKCS1_SHA384,
|
||||
.key_type = EVP_PKEY_RSA,
|
||||
|
@ -75,20 +67,6 @@ const struct ssl_sigalg sigalgs[] = {
|
|||
.security_level = 3,
|
||||
.group_nid = NID_X9_62_prime256v1,
|
||||
},
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
{
|
||||
.value = SIGALG_GOSTR12_256_STREEBOG_256,
|
||||
.key_type = EVP_PKEY_GOSTR12_256,
|
||||
.md = EVP_streebog256,
|
||||
.security_level = 0,
|
||||
},
|
||||
{
|
||||
.value = SIGALG_GOSTR01_GOST94,
|
||||
.key_type = EVP_PKEY_GOSTR01,
|
||||
.md = EVP_gostr341194,
|
||||
.security_level = 0, /* XXX */
|
||||
},
|
||||
#endif
|
||||
{
|
||||
.value = SIGALG_RSA_PSS_RSAE_SHA256,
|
||||
.key_type = EVP_PKEY_RSA,
|
||||
|
@ -283,10 +261,6 @@ ssl_sigalg_for_legacy(SSL *s, EVP_PKEY *pkey)
|
|||
return ssl_sigalg_lookup(SIGALG_RSA_PKCS1_SHA1);
|
||||
case EVP_PKEY_EC:
|
||||
return ssl_sigalg_lookup(SIGALG_ECDSA_SHA1);
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
case EVP_PKEY_GOSTR01:
|
||||
return ssl_sigalg_lookup(SIGALG_GOSTR01_GOST94);
|
||||
#endif
|
||||
}
|
||||
SSLerror(s, SSL_R_UNKNOWN_PKEY_TYPE);
|
||||
return NULL;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_sigalgs.h,v 1.26 2022/07/02 16:00:12 tb Exp $ */
|
||||
/* $OpenBSD: ssl_sigalgs.h,v 1.27 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018-2019 Bob Beck <beck@openbsd.org>
|
||||
*
|
||||
|
@ -47,14 +47,6 @@ __BEGIN_HIDDEN_DECLS
|
|||
#define SIGALG_PRIVATE_START 0xFE00
|
||||
#define SIGALG_PRIVATE_END 0xFFFF
|
||||
|
||||
/*
|
||||
* If Russia can elect the US President, surely
|
||||
* IANA could fix this problem.
|
||||
*/
|
||||
#define SIGALG_GOSTR12_512_STREEBOG_512 0xEFEF
|
||||
#define SIGALG_GOSTR12_256_STREEBOG_256 0xEEEE
|
||||
#define SIGALG_GOSTR01_GOST94 0xEDED
|
||||
|
||||
/* Legacy sigalg for < TLSv1.2 same value as BoringSSL uses. */
|
||||
#define SIGALG_RSA_PKCS1_MD5_SHA1 0xFF01
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ssl_srvr.c,v 1.158 2023/12/29 12:24:33 tb Exp $ */
|
||||
/* $OpenBSD: ssl_srvr.c,v 1.160 2024/02/03 17:39:17 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -162,10 +162,6 @@
|
|||
#include <openssl/opensslconf.h>
|
||||
#include <openssl/x509.h>
|
||||
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
#include <openssl/gost.h>
|
||||
#endif
|
||||
|
||||
#include "bytestring.h"
|
||||
#include "dtls_local.h"
|
||||
#include "ssl_local.h"
|
||||
|
@ -564,15 +560,7 @@ ssl3_accept(SSL *s)
|
|||
}
|
||||
|
||||
alg_k = s->s3->hs.cipher->algorithm_mkey;
|
||||
if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
|
||||
/*
|
||||
* A GOST client may use the key from its
|
||||
* certificate for key exchange, in which case
|
||||
* the CertificateVerify message is not sent.
|
||||
*/
|
||||
s->s3->hs.state = SSL3_ST_SR_FINISHED_A;
|
||||
s->init_num = 0;
|
||||
} else if (SSL_USE_SIGALGS(s) || (alg_k & SSL_kGOST)) {
|
||||
if (SSL_USE_SIGALGS(s)) {
|
||||
s->s3->hs.state = SSL3_ST_SR_CERT_VRFY_A;
|
||||
s->init_num = 0;
|
||||
if (!s->session->peer_cert)
|
||||
|
@ -795,7 +783,6 @@ ssl3_get_client_hello(SSL *s)
|
|||
unsigned long id;
|
||||
SSL_CIPHER *c;
|
||||
STACK_OF(SSL_CIPHER) *ciphers = NULL;
|
||||
unsigned long alg_k;
|
||||
const SSL_METHOD *method;
|
||||
uint16_t shared_version;
|
||||
|
||||
|
@ -1138,9 +1125,7 @@ ssl3_get_client_hello(SSL *s)
|
|||
if (!tls1_transcript_hash_init(s))
|
||||
goto err;
|
||||
|
||||
alg_k = s->s3->hs.cipher->algorithm_mkey;
|
||||
if (!(SSL_USE_SIGALGS(s) || (alg_k & SSL_kGOST)) ||
|
||||
!(s->verify_mode & SSL_VERIFY_PEER))
|
||||
if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER))
|
||||
tls1_transcript_free(s);
|
||||
|
||||
/*
|
||||
|
@ -1815,75 +1800,6 @@ ssl3_get_client_kex_ecdhe(SSL *s, CBS *cbs)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
ssl3_get_client_kex_gost(SSL *s, CBS *cbs)
|
||||
{
|
||||
unsigned char premaster_secret[32];
|
||||
EVP_PKEY_CTX *pkey_ctx = NULL;
|
||||
EVP_PKEY *client_pubkey;
|
||||
EVP_PKEY *pkey = NULL;
|
||||
size_t outlen;
|
||||
CBS gostblob;
|
||||
|
||||
/* Get our certificate private key*/
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
if ((s->s3->hs.cipher->algorithm_auth & SSL_aGOST01) != 0)
|
||||
pkey = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
|
||||
#endif
|
||||
|
||||
if ((pkey_ctx = EVP_PKEY_CTX_new(pkey, NULL)) == NULL)
|
||||
goto err;
|
||||
if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0)
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* If client certificate is present and is of the same type,
|
||||
* maybe use it for key exchange.
|
||||
* Don't mind errors from EVP_PKEY_derive_set_peer, because
|
||||
* it is completely valid to use a client certificate for
|
||||
* authorization only.
|
||||
*/
|
||||
if ((client_pubkey = X509_get0_pubkey(s->session->peer_cert)) != NULL) {
|
||||
if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pubkey) <= 0)
|
||||
ERR_clear_error();
|
||||
}
|
||||
|
||||
/* Decrypt session key */
|
||||
if (!CBS_get_asn1(cbs, &gostblob, CBS_ASN1_SEQUENCE))
|
||||
goto decode_err;
|
||||
if (CBS_len(cbs) != 0)
|
||||
goto decode_err;
|
||||
outlen = sizeof(premaster_secret);
|
||||
if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen,
|
||||
CBS_data(&gostblob), CBS_len(&gostblob)) <= 0) {
|
||||
SSLerror(s, SSL_R_DECRYPTION_FAILED);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!tls12_derive_master_secret(s, premaster_secret,
|
||||
sizeof(premaster_secret)))
|
||||
goto err;
|
||||
|
||||
/* Check if pubkey from client certificate was used */
|
||||
if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY,
|
||||
2, NULL) > 0)
|
||||
s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
|
||||
|
||||
explicit_bzero(premaster_secret, sizeof(premaster_secret));
|
||||
EVP_PKEY_CTX_free(pkey_ctx);
|
||||
|
||||
return 1;
|
||||
|
||||
decode_err:
|
||||
SSLerror(s, SSL_R_BAD_PACKET_LENGTH);
|
||||
ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
|
||||
err:
|
||||
explicit_bzero(premaster_secret, sizeof(premaster_secret));
|
||||
EVP_PKEY_CTX_free(pkey_ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
ssl3_get_client_key_exchange(SSL *s)
|
||||
{
|
||||
|
@ -1912,9 +1828,6 @@ ssl3_get_client_key_exchange(SSL *s)
|
|||
} else if (alg_k & SSL_kECDHE) {
|
||||
if (!ssl3_get_client_kex_ecdhe(s, &cbs))
|
||||
goto err;
|
||||
} else if (alg_k & SSL_kGOST) {
|
||||
if (!ssl3_get_client_kex_gost(s, &cbs))
|
||||
goto err;
|
||||
} else {
|
||||
al = SSL_AD_HANDSHAKE_FAILURE;
|
||||
SSLerror(s, SSL_R_UNKNOWN_CIPHER_TYPE);
|
||||
|
@ -2043,15 +1956,6 @@ ssl3_get_cert_verify(SSL *s)
|
|||
al = SSL_AD_INTERNAL_ERROR;
|
||||
goto fatal_err;
|
||||
}
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
if (sigalg->key_type == EVP_PKEY_GOSTR01 &&
|
||||
EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_VERIFY,
|
||||
EVP_PKEY_CTRL_GOST_SIG_FORMAT, GOST_SIG_FORMAT_RS_LE,
|
||||
NULL) <= 0) {
|
||||
al = SSL_AD_INTERNAL_ERROR;
|
||||
goto fatal_err;
|
||||
}
|
||||
#endif
|
||||
if (EVP_DigestVerify(mctx, CBS_data(&signature),
|
||||
CBS_len(&signature), hdata, hdatalen) <= 0) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
|
@ -2096,54 +2000,6 @@ ssl3_get_cert_verify(SSL *s)
|
|||
SSLerror(s, SSL_R_BAD_ECDSA_SIGNATURE);
|
||||
goto fatal_err;
|
||||
}
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
} else if (EVP_PKEY_id(pkey) == NID_id_GostR3410_94 ||
|
||||
EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
|
||||
unsigned char sigbuf[128];
|
||||
unsigned int siglen = sizeof(sigbuf);
|
||||
EVP_PKEY_CTX *pctx;
|
||||
const EVP_MD *md;
|
||||
int nid;
|
||||
|
||||
if (!tls1_transcript_data(s, &hdata, &hdatalen)) {
|
||||
SSLerror(s, ERR_R_INTERNAL_ERROR);
|
||||
al = SSL_AD_INTERNAL_ERROR;
|
||||
goto fatal_err;
|
||||
}
|
||||
if (!EVP_PKEY_get_default_digest_nid(pkey, &nid) ||
|
||||
!(md = EVP_get_digestbynid(nid))) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
al = SSL_AD_INTERNAL_ERROR;
|
||||
goto fatal_err;
|
||||
}
|
||||
if ((pctx = EVP_PKEY_CTX_new(pkey, NULL)) == NULL) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
al = SSL_AD_INTERNAL_ERROR;
|
||||
goto fatal_err;
|
||||
}
|
||||
if (!EVP_DigestInit_ex(mctx, md, NULL) ||
|
||||
!EVP_DigestUpdate(mctx, hdata, hdatalen) ||
|
||||
!EVP_DigestFinal(mctx, sigbuf, &siglen) ||
|
||||
(EVP_PKEY_verify_init(pctx) <= 0) ||
|
||||
(EVP_PKEY_CTX_set_signature_md(pctx, md) <= 0) ||
|
||||
(EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_VERIFY,
|
||||
EVP_PKEY_CTRL_GOST_SIG_FORMAT,
|
||||
GOST_SIG_FORMAT_RS_LE, NULL) <= 0)) {
|
||||
SSLerror(s, ERR_R_EVP_LIB);
|
||||
al = SSL_AD_INTERNAL_ERROR;
|
||||
EVP_PKEY_CTX_free(pctx);
|
||||
goto fatal_err;
|
||||
}
|
||||
if (EVP_PKEY_verify(pctx, CBS_data(&signature),
|
||||
CBS_len(&signature), sigbuf, siglen) <= 0) {
|
||||
al = SSL_AD_DECRYPT_ERROR;
|
||||
SSLerror(s, SSL_R_BAD_SIGNATURE);
|
||||
EVP_PKEY_CTX_free(pctx);
|
||||
goto fatal_err;
|
||||
}
|
||||
|
||||
EVP_PKEY_CTX_free(pctx);
|
||||
#endif
|
||||
} else {
|
||||
SSLerror(s, ERR_R_INTERNAL_ERROR);
|
||||
al = SSL_AD_UNSUPPORTED_CERTIFICATE;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls1.h,v 1.56 2022/07/17 14:39:09 jsing Exp $ */
|
||||
/* $OpenBSD: tls1.h,v 1.57 2024/02/03 15:58:34 beck Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
@ -741,18 +741,12 @@ SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,(void (*)(void))cb)
|
|||
#define TLS_CT_DSS_SIGN 2
|
||||
#define TLS_CT_RSA_FIXED_DH 3
|
||||
#define TLS_CT_DSS_FIXED_DH 4
|
||||
#define TLS_CT_GOST94_SIGN 21
|
||||
#define TLS_CT_GOST01_SIGN 22
|
||||
#define TLS_CT_ECDSA_SIGN 64
|
||||
#define TLS_CT_RSA_FIXED_ECDH 65
|
||||
#define TLS_CT_ECDSA_FIXED_ECDH 66
|
||||
#define TLS_CT_GOST12_256_SIGN 67
|
||||
#define TLS_CT_GOST12_512_SIGN 68
|
||||
#define TLS_CT_GOST12_256_SIGN_COMPAT 238 /* pre-IANA, for compat */
|
||||
#define TLS_CT_GOST12_512_SIGN_COMPAT 239 /* pre-IANA, for compat */
|
||||
/* when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see
|
||||
* comment there) */
|
||||
#define TLS_CT_NUMBER 13
|
||||
#define TLS_CT_NUMBER 7
|
||||
|
||||
#define TLS1_FINISH_MAC_LENGTH 12
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls12_key_schedule.c,v 1.3 2022/11/26 16:08:56 tb Exp $ */
|
||||
/* $OpenBSD: tls12_key_schedule.c,v 1.4 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2021 Joel Sing <jsing@openbsd.org>
|
||||
*
|
||||
|
@ -124,10 +124,6 @@ tls12_key_block_generate(struct tls12_key_block *kb, SSL *s,
|
|||
mac_key_len = EVP_MD_size(mac_hash);
|
||||
key_len = EVP_CIPHER_key_length(cipher);
|
||||
iv_len = EVP_CIPHER_iv_length(cipher);
|
||||
|
||||
/* Special handling for GOST... */
|
||||
if (EVP_MD_type(mac_hash) == NID_id_Gost28147_89_MAC)
|
||||
mac_key_len = 32;
|
||||
}
|
||||
|
||||
if (mac_key_len > EVP_MAX_MD_SIZE)
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls12_record_layer.c,v 1.41 2024/01/18 16:30:43 tb Exp $ */
|
||||
/* $OpenBSD: tls12_record_layer.c,v 1.42 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2020 Joel Sing <jsing@openbsd.org>
|
||||
*
|
||||
|
@ -468,7 +468,6 @@ tls12_record_layer_ccs_cipher(struct tls12_record_layer *rl,
|
|||
CBS *iv)
|
||||
{
|
||||
EVP_PKEY *mac_pkey = NULL;
|
||||
int gost_param_nid;
|
||||
int mac_type;
|
||||
int ret = 0;
|
||||
|
||||
|
@ -484,25 +483,10 @@ tls12_record_layer_ccs_cipher(struct tls12_record_layer *rl,
|
|||
goto err;
|
||||
if (EVP_CIPHER_key_length(rl->cipher) != CBS_len(key))
|
||||
goto err;
|
||||
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
/* XXX die die die */
|
||||
/* Special handling for GOST... */
|
||||
if (EVP_MD_type(rl->mac_hash) == NID_id_Gost28147_89_MAC) {
|
||||
if (CBS_len(mac_key) != 32)
|
||||
goto err;
|
||||
mac_type = EVP_PKEY_GOSTIMIT;
|
||||
rp->stream_mac = 1;
|
||||
} else {
|
||||
#endif
|
||||
if (CBS_len(mac_key) > INT_MAX)
|
||||
goto err;
|
||||
if (EVP_MD_size(rl->mac_hash) != CBS_len(mac_key))
|
||||
goto err;
|
||||
#ifndef OPENSSL_NO_GOST
|
||||
}
|
||||
#endif
|
||||
|
||||
if (CBS_len(mac_key) > INT_MAX)
|
||||
goto err;
|
||||
if (EVP_MD_size(rl->mac_hash) != CBS_len(mac_key))
|
||||
goto err;
|
||||
if ((rp->cipher_ctx = EVP_CIPHER_CTX_new()) == NULL)
|
||||
goto err;
|
||||
if ((rp->hash_ctx = EVP_MD_CTX_new()) == NULL)
|
||||
|
@ -524,23 +508,6 @@ tls12_record_layer_ccs_cipher(struct tls12_record_layer *rl,
|
|||
mac_pkey) <= 0)
|
||||
goto err;
|
||||
|
||||
/* More special handling for GOST... */
|
||||
if (EVP_CIPHER_nid(rl->cipher) == NID_gost89_cnt) {
|
||||
gost_param_nid = NID_id_tc26_gost_28147_param_Z;
|
||||
if (EVP_MD_type(rl->handshake_hash) == NID_id_GostR3411_94)
|
||||
gost_param_nid = NID_id_Gost28147_89_CryptoPro_A_ParamSet;
|
||||
|
||||
if (EVP_CIPHER_CTX_ctrl(rp->cipher_ctx, EVP_CTRL_GOST_SET_SBOX,
|
||||
gost_param_nid, 0) <= 0)
|
||||
goto err;
|
||||
|
||||
if (EVP_MD_type(rl->mac_hash) == NID_id_Gost28147_89_MAC) {
|
||||
if (EVP_MD_CTX_ctrl(rp->hash_ctx, EVP_MD_CTRL_GOST_SET_SBOX,
|
||||
gost_param_nid, 0) <= 0)
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls13_handshake.c,v 1.72 2022/11/26 16:08:56 tb Exp $ */
|
||||
/* $OpenBSD: tls13_handshake.c,v 1.73 2024/02/03 19:57:14 tb Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018-2021 Theo Buehler <tb@openbsd.org>
|
||||
* Copyright (c) 2019 Joel Sing <jsing@openbsd.org>
|
||||
|
@ -546,22 +546,24 @@ tls13_handshake_recv_action(struct tls13_ctx *ctx,
|
|||
return TLS13_IO_FAILURE;
|
||||
|
||||
ret = TLS13_IO_FAILURE;
|
||||
if (action->recv(ctx, &cbs)) {
|
||||
if (CBS_len(&cbs) != 0) {
|
||||
tls13_set_errorx(ctx, TLS13_ERR_TRAILING_DATA, 0,
|
||||
"trailing data in handshake message", NULL);
|
||||
ctx->alert = TLS13_ALERT_DECODE_ERROR;
|
||||
} else {
|
||||
ret = TLS13_IO_SUCCESS;
|
||||
}
|
||||
if (!action->recv(ctx, &cbs))
|
||||
goto err;
|
||||
|
||||
if (CBS_len(&cbs) != 0) {
|
||||
tls13_set_errorx(ctx, TLS13_ERR_TRAILING_DATA, 0,
|
||||
"trailing data in handshake message", NULL);
|
||||
ctx->alert = TLS13_ALERT_DECODE_ERROR;
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = TLS13_IO_SUCCESS;
|
||||
if (ctx->ssl->method->version < TLS1_3_VERSION)
|
||||
ret = TLS13_IO_USE_LEGACY;
|
||||
|
||||
err:
|
||||
tls13_handshake_msg_free(ctx->hs_msg);
|
||||
ctx->hs_msg = NULL;
|
||||
|
||||
if (ctx->ssl->method->version < TLS1_3_VERSION)
|
||||
return TLS13_IO_USE_LEGACY;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: clienttest.c,v 1.42 2023/07/11 17:03:44 tb Exp $ */
|
||||
/* $OpenBSD: clienttest.c,v 1.43 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2015 Joel Sing <jsing@openbsd.org>
|
||||
*
|
||||
|
@ -36,7 +36,7 @@
|
|||
#define TLS13_RANDOM_OFFSET (TLS13_HM_OFFSET + 2)
|
||||
#define TLS13_SESSION_OFFSET (TLS13_HM_OFFSET + 34)
|
||||
#define TLS13_CIPHER_OFFSET (TLS13_HM_OFFSET + 69)
|
||||
#define TLS13_KEY_SHARE_OFFSET (TLS13_HM_OFFSET + 188)
|
||||
#define TLS13_KEY_SHARE_OFFSET (TLS13_HM_OFFSET + 184)
|
||||
#define TLS13_ONLY_KEY_SHARE_OFFSET (TLS13_HM_OFFSET + 98)
|
||||
|
||||
#define TLS1_3_VERSION_ONLY (TLS1_3_VERSION | 0x10000)
|
||||
|
@ -75,57 +75,54 @@ static const uint8_t cipher_list_dtls12_aes[] = {
|
|||
0xc0, 0x30, 0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24,
|
||||
0xc0, 0x14, 0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b,
|
||||
0x00, 0x39, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa,
|
||||
0xff, 0x85, 0x00, 0xc4, 0x00, 0x88, 0x00, 0x81,
|
||||
0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0,
|
||||
0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27,
|
||||
0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e,
|
||||
0x00, 0x67, 0x00, 0x33, 0x00, 0xbe, 0x00, 0x45,
|
||||
0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba,
|
||||
0x00, 0x41, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x00, 0xff
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d,
|
||||
0x00, 0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f,
|
||||
0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13,
|
||||
0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33,
|
||||
0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c,
|
||||
0x00, 0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x12,
|
||||
0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_dtls12_chacha[] = {
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xc0, 0x30,
|
||||
0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24, 0xc0, 0x14,
|
||||
0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39,
|
||||
0xff, 0x85, 0x00, 0xc4, 0x00, 0x88, 0x00, 0x81,
|
||||
0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0,
|
||||
0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27,
|
||||
0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e,
|
||||
0x00, 0x67, 0x00, 0x33, 0x00, 0xbe, 0x00, 0x45,
|
||||
0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba,
|
||||
0x00, 0x41, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x00, 0xff,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d,
|
||||
0x00, 0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f,
|
||||
0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13,
|
||||
0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33,
|
||||
0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c,
|
||||
0x00, 0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x12,
|
||||
0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t client_hello_dtls12[] = {
|
||||
0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xbe, 0x01, 0x00, 0x00,
|
||||
0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xb2, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xba, 0x01, 0x00, 0x00,
|
||||
0xae, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xae, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xc0,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xc0,
|
||||
0x30, 0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24, 0xc0,
|
||||
0x14, 0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b, 0x00,
|
||||
0x39, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xff,
|
||||
0x85, 0x00, 0xc4, 0x00, 0x88, 0x00, 0x81, 0x00,
|
||||
0x9d, 0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0, 0x00,
|
||||
0x84, 0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27, 0xc0,
|
||||
0x23, 0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e, 0x00,
|
||||
0x67, 0x00, 0x33, 0x00, 0xbe, 0x00, 0x45, 0x00,
|
||||
0x9c, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba, 0x00,
|
||||
0x41, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16, 0x00,
|
||||
0x0a, 0x00, 0xff, 0x01, 0x00, 0x00, 0x34, 0x00,
|
||||
0x0b, 0x00, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00,
|
||||
0x0a, 0x00, 0x08, 0x00, 0x1d, 0x00, 0x17, 0x00,
|
||||
0x18, 0x00, 0x19, 0x00, 0x23, 0x00, 0x00, 0x00,
|
||||
0x0d, 0x00, 0x18, 0x00, 0x16, 0x08, 0x06, 0x06,
|
||||
0x01, 0x06, 0x03, 0x08, 0x05, 0x05, 0x01, 0x05,
|
||||
0x03, 0x08, 0x04, 0x04, 0x01, 0x04, 0x03, 0x02,
|
||||
0x01, 0x02, 0x03,
|
||||
0x39, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0x00,
|
||||
0xc4, 0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d, 0x00,
|
||||
0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f, 0xc0,
|
||||
0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13, 0xc0,
|
||||
0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33, 0x00,
|
||||
0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c, 0x00,
|
||||
0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x12, 0xc0,
|
||||
0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff, 0x01,
|
||||
0x00, 0x00, 0x34, 0x00, 0x0b, 0x00, 0x02, 0x01,
|
||||
0x00, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x08, 0x00,
|
||||
0x1d, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00,
|
||||
0x23, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x18, 0x00,
|
||||
0x16, 0x08, 0x06, 0x06, 0x01, 0x06, 0x03, 0x08,
|
||||
0x05, 0x05, 0x01, 0x05, 0x03, 0x08, 0x04, 0x04,
|
||||
0x01, 0x04, 0x03, 0x02, 0x01, 0x02, 0x03,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_tls10[] = {
|
||||
|
@ -186,92 +183,90 @@ static const uint8_t cipher_list_tls12_aes[] = {
|
|||
0xc0, 0x30, 0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24,
|
||||
0xc0, 0x14, 0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b,
|
||||
0x00, 0x39, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa,
|
||||
0xff, 0x85, 0x00, 0xc4, 0x00, 0x88, 0x00, 0x81,
|
||||
0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0,
|
||||
0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27,
|
||||
0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e,
|
||||
0x00, 0x67, 0x00, 0x33, 0x00, 0xbe, 0x00, 0x45,
|
||||
0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba,
|
||||
0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07, 0x00, 0x05,
|
||||
0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a,
|
||||
0x00, 0xff,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d,
|
||||
0x00, 0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f,
|
||||
0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13,
|
||||
0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33,
|
||||
0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c,
|
||||
0x00, 0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x11,
|
||||
0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08,
|
||||
0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_tls12_chacha[] = {
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xc0, 0x30,
|
||||
0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24, 0xc0, 0x14,
|
||||
0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39,
|
||||
0xff, 0x85, 0x00, 0xc4, 0x00, 0x88, 0x00, 0x81,
|
||||
0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0,
|
||||
0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27,
|
||||
0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e,
|
||||
0x00, 0x67, 0x00, 0x33, 0x00, 0xbe, 0x00, 0x45,
|
||||
0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba,
|
||||
0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07, 0x00, 0x05,
|
||||
0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a,
|
||||
0x00, 0xff,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d,
|
||||
0x00, 0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f,
|
||||
0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13,
|
||||
0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33,
|
||||
0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c,
|
||||
0x00, 0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x11,
|
||||
0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08,
|
||||
0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t client_hello_tls12[] = {
|
||||
0x16, 0x03, 0x03, 0x00, 0xbb, 0x01, 0x00, 0x00,
|
||||
0xb7, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x16, 0x03, 0x03, 0x00, 0xb7, 0x01, 0x00, 0x00,
|
||||
0xb3, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xc0, 0x30,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0xc0, 0x30,
|
||||
0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24, 0xc0, 0x14,
|
||||
0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39,
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xff, 0x85,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x81, 0x00, 0x9d,
|
||||
0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0, 0x00, 0x84,
|
||||
0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23,
|
||||
0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67,
|
||||
0x00, 0x33, 0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c,
|
||||
0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba, 0x00, 0x41,
|
||||
0xc0, 0x11, 0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12,
|
||||
0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
0x01, 0x00, 0x00, 0x34, 0x00, 0x0b, 0x00, 0x02,
|
||||
0x01, 0x00, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x08,
|
||||
0x00, 0x1d, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19,
|
||||
0x00, 0x23, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x18,
|
||||
0x00, 0x16, 0x08, 0x06, 0x06, 0x01, 0x06, 0x03,
|
||||
0x08, 0x05, 0x05, 0x01, 0x05, 0x03, 0x08, 0x04,
|
||||
0x04, 0x01, 0x04, 0x03, 0x02, 0x01, 0x02, 0x03,
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0x00, 0xc4,
|
||||
0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35,
|
||||
0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b,
|
||||
0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09,
|
||||
0x00, 0x9e, 0x00, 0x67, 0x00, 0x33, 0x00, 0xbe,
|
||||
0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f,
|
||||
0x00, 0xba, 0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07,
|
||||
0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x00, 0xff, 0x01, 0x00, 0x00, 0x34,
|
||||
0x00, 0x0b, 0x00, 0x02, 0x01, 0x00, 0x00, 0x0a,
|
||||
0x00, 0x0a, 0x00, 0x08, 0x00, 0x1d, 0x00, 0x17,
|
||||
0x00, 0x18, 0x00, 0x19, 0x00, 0x23, 0x00, 0x00,
|
||||
0x00, 0x0d, 0x00, 0x18, 0x00, 0x16, 0x08, 0x06,
|
||||
0x06, 0x01, 0x06, 0x03, 0x08, 0x05, 0x05, 0x01,
|
||||
0x05, 0x03, 0x08, 0x04, 0x04, 0x01, 0x04, 0x03,
|
||||
0x02, 0x01, 0x02, 0x03,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_tls13_aes[] = {
|
||||
0x13, 0x02, 0x13, 0x03, 0x13, 0x01, 0xc0, 0x30,
|
||||
0xc0, 0x2c, 0xc0, 0x28, 0xc0, 0x24, 0xc0, 0x14,
|
||||
0xc0, 0x0a, 0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39,
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xff, 0x85,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x81, 0x00, 0x9d,
|
||||
0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0, 0x00, 0x84,
|
||||
0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23,
|
||||
0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67,
|
||||
0x00, 0x33, 0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c,
|
||||
0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba, 0x00, 0x41,
|
||||
0xc0, 0x11, 0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12,
|
||||
0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0x00, 0xc4,
|
||||
0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35,
|
||||
0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b,
|
||||
0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09,
|
||||
0x00, 0x9e, 0x00, 0x67, 0x00, 0x33, 0x00, 0xbe,
|
||||
0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f,
|
||||
0x00, 0xba, 0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07,
|
||||
0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_tls13_chacha[] = {
|
||||
0x13, 0x03, 0x13, 0x02, 0x13, 0x01, 0xcc, 0xa9,
|
||||
0xcc, 0xa8, 0xcc, 0xaa, 0xc0, 0x30, 0xc0, 0x2c,
|
||||
0xc0, 0x28, 0xc0, 0x24, 0xc0, 0x14, 0xc0, 0x0a,
|
||||
0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39, 0xff, 0x85,
|
||||
0x00, 0xc4, 0x00, 0x88, 0x00, 0x81, 0x00, 0x9d,
|
||||
0x00, 0x3d, 0x00, 0x35, 0x00, 0xc0, 0x00, 0x84,
|
||||
0xc0, 0x2f, 0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23,
|
||||
0xc0, 0x13, 0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67,
|
||||
0x00, 0x33, 0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c,
|
||||
0x00, 0x3c, 0x00, 0x2f, 0x00, 0xba, 0x00, 0x41,
|
||||
0xc0, 0x11, 0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12,
|
||||
0xc0, 0x08, 0x00, 0x16, 0x00, 0x0a, 0x00, 0xff,
|
||||
0x00, 0x9f, 0x00, 0x6b, 0x00, 0x39, 0x00, 0xc4,
|
||||
0x00, 0x88, 0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35,
|
||||
0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b,
|
||||
0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09,
|
||||
0x00, 0x9e, 0x00, 0x67, 0x00, 0x33, 0x00, 0xbe,
|
||||
0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f,
|
||||
0x00, 0xba, 0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07,
|
||||
0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x00, 0xff,
|
||||
};
|
||||
|
||||
static const uint8_t client_hello_tls13[] = {
|
||||
0x16, 0x03, 0x03, 0x01, 0x14, 0x01, 0x00, 0x01,
|
||||
0x10, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x16, 0x03, 0x03, 0x01, 0x10, 0x01, 0x00, 0x01,
|
||||
0x0c, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
|
@ -279,33 +274,32 @@ static const uint8_t client_hello_tls13[] = {
|
|||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x13, 0x03,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x13, 0x03,
|
||||
0x13, 0x02, 0x13, 0x01, 0xcc, 0xa9, 0xcc, 0xa8,
|
||||
0xcc, 0xaa, 0xc0, 0x30, 0xc0, 0x2c, 0xc0, 0x28,
|
||||
0xc0, 0x24, 0xc0, 0x14, 0xc0, 0x0a, 0x00, 0x9f,
|
||||
0x00, 0x6b, 0x00, 0x39, 0xff, 0x85, 0x00, 0xc4,
|
||||
0x00, 0x88, 0x00, 0x81, 0x00, 0x9d, 0x00, 0x3d,
|
||||
0x00, 0x35, 0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f,
|
||||
0xc0, 0x2b, 0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13,
|
||||
0xc0, 0x09, 0x00, 0x9e, 0x00, 0x67, 0x00, 0x33,
|
||||
0x00, 0xbe, 0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c,
|
||||
0x00, 0x2f, 0x00, 0xba, 0x00, 0x41, 0xc0, 0x11,
|
||||
0xc0, 0x07, 0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08,
|
||||
0x00, 0x16, 0x00, 0x0a, 0x00, 0xff, 0x01, 0x00,
|
||||
0x00, 0x67, 0x00, 0x2b, 0x00, 0x05, 0x04, 0x03,
|
||||
0x04, 0x03, 0x03, 0x00, 0x33, 0x00, 0x26, 0x00,
|
||||
0x24, 0x00, 0x1d, 0x00, 0x20, 0x00, 0x00, 0x00,
|
||||
0x00, 0x6b, 0x00, 0x39, 0x00, 0xc4, 0x00, 0x88,
|
||||
0x00, 0x81, 0x00, 0x9d, 0x00, 0x3d, 0x00, 0x35,
|
||||
0x00, 0xc0, 0x00, 0x84, 0xc0, 0x2f, 0xc0, 0x2b,
|
||||
0xc0, 0x27, 0xc0, 0x23, 0xc0, 0x13, 0xc0, 0x09,
|
||||
0x00, 0x9e, 0x00, 0x67, 0x00, 0x33, 0x00, 0xbe,
|
||||
0x00, 0x45, 0x00, 0x9c, 0x00, 0x3c, 0x00, 0x2f,
|
||||
0x00, 0xba, 0x00, 0x41, 0xc0, 0x11, 0xc0, 0x07,
|
||||
0x00, 0x05, 0xc0, 0x12, 0xc0, 0x08, 0x00, 0x16,
|
||||
0x00, 0x0a, 0x01, 0x00, 0x00, 0x67, 0x00, 0x2b,
|
||||
0x00, 0x05, 0x04, 0x03, 0x04, 0x03, 0x03, 0x00,
|
||||
0x33, 0x00, 0x26, 0x00, 0x24, 0x00, 0x1d, 0x00,
|
||||
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00,
|
||||
0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x0a, 0x00,
|
||||
0x08, 0x00, 0x1d, 0x00, 0x17, 0x00, 0x18, 0x00,
|
||||
0x19, 0x00, 0x23, 0x00, 0x00, 0x00, 0x0d, 0x00,
|
||||
0x18, 0x00, 0x16, 0x08, 0x06, 0x06, 0x01, 0x06,
|
||||
0x03, 0x08, 0x05, 0x05, 0x01, 0x05, 0x03, 0x08,
|
||||
0x04, 0x04, 0x01, 0x04, 0x03, 0x02, 0x01, 0x02,
|
||||
0x03,
|
||||
0x00, 0x00, 0x0b, 0x00, 0x02, 0x01, 0x00, 0x00,
|
||||
0x0a, 0x00, 0x0a, 0x00, 0x08, 0x00, 0x1d, 0x00,
|
||||
0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x23, 0x00,
|
||||
0x00, 0x00, 0x0d, 0x00, 0x18, 0x00, 0x16, 0x08,
|
||||
0x06, 0x06, 0x01, 0x06, 0x03, 0x08, 0x05, 0x05,
|
||||
0x01, 0x05, 0x03, 0x08, 0x04, 0x04, 0x01, 0x04,
|
||||
0x03, 0x02, 0x01, 0x02, 0x03,
|
||||
};
|
||||
|
||||
static const uint8_t cipher_list_tls13_only_aes[] = {
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
# $OpenBSD: Makefile.inc,v 1.9 2023/10/18 19:14:32 anton Exp $
|
||||
# $OpenBSD: Makefile.inc,v 1.10 2024/02/03 15:58:34 beck Exp $
|
||||
|
||||
.PATH: ${.CURDIR}/..
|
||||
|
||||
|
@ -39,7 +39,7 @@ run-self-client-server: client server 127.0.0.1.crt
|
|||
CLEANFILES += 127.0.0.1.{crt,key} \
|
||||
ca.{crt,key,srl} fake-ca.{crt,key} \
|
||||
{client,server}.{req,crt,key} \
|
||||
{dsa,ec,gost,rsa}.{key,req,crt} \
|
||||
{dsa,ec,rsa}.{key,req,crt} \
|
||||
dh.param
|
||||
|
||||
127.0.0.1.crt:
|
||||
|
@ -70,10 +70,6 @@ dsa.key:
|
|||
ec.key:
|
||||
openssl ecparam -genkey -name secp256r1 -out $@
|
||||
|
||||
gost.key:
|
||||
openssl genpkey -algorithm gost2001 \
|
||||
-pkeyopt paramset:A -pkeyopt dgst:md_gost94 -out $@
|
||||
|
||||
rsa.key:
|
||||
openssl genrsa -out $@ 2048
|
||||
|
||||
|
@ -82,11 +78,6 @@ dsa.req ec.req rsa.req: ${@:R}.key
|
|||
-subj /L=OpenBSD/O=tls-regress/OU=${@:R}/CN=localhost/ \
|
||||
-nodes -key ${@:R}.key -out $@
|
||||
|
||||
gost.req: ${@:R}.key
|
||||
openssl req -batch -new -md_gost94 \
|
||||
-subj /L=OpenBSD/O=tls-regress/OU=${@:R}/CN=localhost/ \
|
||||
-nodes -key ${@:R}.key -out $@
|
||||
|
||||
dsa.crt ec.crt gost.crt rsa.crt: ca.crt ${@:R}.req
|
||||
dsa.crt ec.crt rsa.crt: ca.crt ${@:R}.req
|
||||
openssl x509 -CAcreateserial -CAkey ca.key -CA ca.crt \
|
||||
-req -in ${@:R}.req -out $@
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
# $OpenBSD: Makefile,v 1.13 2023/10/30 17:15:21 tb Exp $
|
||||
# $OpenBSD: Makefile,v 1.14 2024/02/03 15:58:34 beck Exp $
|
||||
|
||||
# Connect a client to a server. Both can be current libressl, or
|
||||
# openssl 1.1 or 3.0. Create lists of supported ciphers
|
||||
|
@ -6,17 +6,6 @@
|
|||
# certificate with compatible type. Check that client and server
|
||||
# have used correct cipher by grepping in their session print out.
|
||||
|
||||
run-cipher-GOST2001-GOST89-GOST89-client-libressl-server-libressl \
|
||||
run-cipher-GOST2012256-GOST89-GOST89-client-libressl-server-libressl \
|
||||
client-cipher-GOST2012256-GOST89-GOST89-client-libressl-server-libressl.out \
|
||||
client-cipher-GOST2001-GOST89-GOST89-client-libressl-server-libressl.out \
|
||||
server-cipher-GOST2001-GOST89-GOST89-client-libressl-server-libressl.out \
|
||||
server-cipher-GOST2012256-GOST89-GOST89-client-libressl-server-libressl.out \
|
||||
check-cipher-GOST2001-GOST89-GOST89-client-libressl-server-libressl \
|
||||
check-cipher-GOST2012256-GOST89-GOST89-client-libressl-server-libressl:
|
||||
# gost does not work with libressl TLS 1.3 right now
|
||||
@echo DISABLED
|
||||
|
||||
LIBRARIES = libressl
|
||||
.if exists(/usr/local/bin/eopenssl11)
|
||||
LIBRARIES += openssl11
|
||||
|
@ -96,8 +85,6 @@ LEVEL_openssl30 = ,@SECLEVEL=0
|
|||
TYPE_${cipher} = dsa
|
||||
.elif "${cipher:M*-ECDSA-*}" != ""
|
||||
TYPE_${cipher} = ec
|
||||
.elif "${cipher:M*-GOST89-*}" != ""
|
||||
TYPE_${cipher} = gost
|
||||
.elif "${cipher:M*-RSA-*}" != ""
|
||||
TYPE_${cipher} = rsa
|
||||
.else
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: tls_prf.c,v 1.8 2022/11/26 16:08:57 tb Exp $ */
|
||||
/* $OpenBSD: tls_prf.c,v 1.9 2024/02/03 15:58:34 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2017 Joel Sing <jsing@openbsd.org>
|
||||
*
|
||||
|
@ -57,29 +57,6 @@ static struct tls_prf_test tls_prf_tests[] = {
|
|||
0x12, 0x44, 0xec, 0x60, 0x61, 0xd1, 0x8a, 0x66,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "GOST94",
|
||||
.ssl_method = TLSv1_2_method,
|
||||
.cipher_value = 0x0081,
|
||||
.out = {
|
||||
0xcc, 0xd4, 0x89, 0x5f, 0x52, 0x08, 0x9b, 0xc7,
|
||||
0xf9, 0xb5, 0x83, 0x58, 0xe8, 0xc7, 0x71, 0x49,
|
||||
0x39, 0x99, 0x1f, 0x14, 0x8f, 0x85, 0xbe, 0x64,
|
||||
0xee, 0x40, 0x5c, 0xe7, 0x5f, 0x68, 0xaf, 0xf2,
|
||||
0xcd, 0x3a, 0x94, 0x52, 0x33, 0x53, 0x46, 0x7d,
|
||||
0xb6, 0xc5, 0xe1, 0xb8, 0xa4, 0x04, 0x69, 0x91,
|
||||
0x0a, 0x9c, 0x88, 0x86, 0xd9, 0x60, 0x63, 0xdd,
|
||||
0xd8, 0xe7, 0x2e, 0xee, 0xce, 0xe2, 0x20, 0xd8,
|
||||
0x9a, 0xfa, 0x9c, 0x63, 0x0c, 0x9c, 0xa1, 0x76,
|
||||
0xed, 0x78, 0x9a, 0x84, 0x70, 0xb4, 0xd1, 0x51,
|
||||
0x1f, 0xde, 0x44, 0xe8, 0x90, 0x21, 0x3f, 0xeb,
|
||||
0x05, 0xf4, 0x77, 0x59, 0xf3, 0xad, 0xdd, 0x34,
|
||||
0x3d, 0x3a, 0x7c, 0xd0, 0x59, 0x40, 0xe1, 0x3f,
|
||||
0x04, 0x4b, 0x8b, 0xd6, 0x95, 0x46, 0xb4, 0x9e,
|
||||
0x4c, 0x2d, 0xf7, 0xee, 0xbd, 0xbc, 0xcb, 0x5c,
|
||||
0x3a, 0x36, 0x0c, 0xd0, 0x27, 0xcb, 0x45, 0x06,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "SHA256 (via TLSv1.2)",
|
||||
.ssl_method = TLSv1_2_method,
|
||||
|
@ -126,29 +103,6 @@ static struct tls_prf_test tls_prf_tests[] = {
|
|||
0x05, 0x76, 0x4b, 0xe4, 0x28, 0x50, 0x4a, 0xf2,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "STREEBOG256",
|
||||
.ssl_method = TLSv1_2_method,
|
||||
.cipher_value = 0xff87,
|
||||
.out = {
|
||||
0x3e, 0x13, 0xb9, 0xeb, 0x85, 0x8c, 0xb4, 0x21,
|
||||
0x23, 0x40, 0x9b, 0x73, 0x04, 0x56, 0xe2, 0xff,
|
||||
0xce, 0x52, 0x1f, 0x82, 0x7f, 0x17, 0x5b, 0x80,
|
||||
0x23, 0x71, 0xca, 0x30, 0xdf, 0xfc, 0xdc, 0x2d,
|
||||
0xc0, 0xfc, 0x5d, 0x23, 0x5a, 0x54, 0x7f, 0xae,
|
||||
0xf5, 0x7d, 0x52, 0x1e, 0x86, 0x95, 0xe1, 0x2d,
|
||||
0x28, 0xe7, 0xbe, 0xd7, 0xd0, 0xbf, 0xa9, 0x96,
|
||||
0x13, 0xd0, 0x9c, 0x0c, 0x1c, 0x16, 0x05, 0xbb,
|
||||
0x26, 0xd7, 0x30, 0x39, 0xb9, 0x53, 0x28, 0x98,
|
||||
0x4f, 0x1b, 0x83, 0xc3, 0xce, 0x1c, 0x7c, 0x34,
|
||||
0xa2, 0xc4, 0x7a, 0x54, 0x16, 0xc6, 0xa7, 0x9e,
|
||||
0xed, 0x4b, 0x7b, 0x83, 0xa6, 0xae, 0xe2, 0x5b,
|
||||
0x96, 0xf5, 0x6c, 0xad, 0x1f, 0xa3, 0x83, 0xb2,
|
||||
0x84, 0x32, 0xed, 0xe3, 0x2c, 0xf6, 0xd4, 0x73,
|
||||
0x30, 0xef, 0x9d, 0xbe, 0xe7, 0x23, 0x9a, 0xbf,
|
||||
0x4d, 0x1c, 0xe7, 0xef, 0x3d, 0xea, 0x46, 0xe2,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
#define N_TLS_PRF_TESTS \
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: traverse.c,v 1.41 2024/01/09 03:16:00 guenther Exp $ */
|
||||
/* $OpenBSD: traverse.c,v 1.42 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: traverse.c,v 1.17 1997/06/05 11:13:27 lukem Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -163,30 +163,6 @@ fs_mapinodes(ino_t maxino, int64_t *tapesize, int *anydirskipped)
|
|||
inosused = cgp->cg_initediblk;
|
||||
else
|
||||
inosused = sblock->fs_ipg;
|
||||
/*
|
||||
* If we are using soft updates, then we can trust the
|
||||
* cylinder group inode allocation maps to tell us which
|
||||
* inodes are allocated. We will scan the used inode map
|
||||
* to find the inodes that are really in use, and then
|
||||
* read only those inodes in from disk.
|
||||
*/
|
||||
if (sblock->fs_flags & FS_DOSOFTDEP) {
|
||||
if (!cg_chkmagic(cgp))
|
||||
quit("mapfiles: cg %d: bad magic number\n", cg);
|
||||
cp = &cg_inosused(cgp)[(inosused - 1) / CHAR_BIT];
|
||||
for ( ; inosused > 0; inosused -= CHAR_BIT, cp--) {
|
||||
if (*cp == 0)
|
||||
continue;
|
||||
for (i = 1 << (CHAR_BIT - 1); i > 0; i >>= 1) {
|
||||
if (*cp & i)
|
||||
break;
|
||||
inosused--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (inosused <= 0)
|
||||
continue;
|
||||
}
|
||||
for (i = 0; i < inosused; i++, ino++) {
|
||||
if (ino < ROOTINO)
|
||||
continue;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dumpfs.c,v 1.37 2022/12/04 23:50:46 cheloha Exp $ */
|
||||
/* $OpenBSD: dumpfs.c,v 1.38 2024/02/03 18:51:57 beck Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2002 Networks Associates Technology, Inc.
|
||||
|
@ -273,12 +273,10 @@ dumpfs(int fd, const char *name)
|
|||
printf("none");
|
||||
if (fsflags & FS_UNCLEAN)
|
||||
printf("unclean ");
|
||||
if (fsflags & FS_DOSOFTDEP)
|
||||
printf("soft-updates ");
|
||||
if (fsflags & FS_FLAGS_UPDATED)
|
||||
printf("updated ");
|
||||
#if 0
|
||||
fsflags &= ~(FS_UNCLEAN | FS_DOSOFTDEP | FS_FLAGS_UPDATED);
|
||||
fsflags &= ~(FS_UNCLEAN | FS_FLAGS_UPDATED);
|
||||
if (fsflags != 0)
|
||||
printf("unknown flags (%#x)", fsflags);
|
||||
#endif
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dir.c,v 1.34 2024/01/09 03:16:00 guenther Exp $ */
|
||||
/* $OpenBSD: dir.c,v 1.35 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: dir.c,v 1.20 1996/09/27 22:45:11 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -265,7 +265,7 @@ adjust(struct inodesc *idesc, short lcnt)
|
|||
pinode(idesc->id_number);
|
||||
printf(" COUNT %d SHOULD BE %d", DIP(dp, di_nlink),
|
||||
DIP(dp, di_nlink) - lcnt);
|
||||
if (preen || usedsoftdep) {
|
||||
if (preen) {
|
||||
if (lcnt < 0) {
|
||||
printf("\n");
|
||||
pfatal("LINK COUNT INCREASING");
|
||||
|
@ -332,7 +332,7 @@ linkup(ino_t orphan, ino_t parentdir)
|
|||
lostdir = (DIP(dp, di_mode) & IFMT) == IFDIR;
|
||||
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
|
||||
pinode(orphan);
|
||||
if ((preen || usedsoftdep) && DIP(dp, di_size) == 0)
|
||||
if (preen && DIP(dp, di_size) == 0)
|
||||
return (0);
|
||||
if (preen)
|
||||
printf(" (RECONNECTED)\n");
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: fsck.h,v 1.34 2021/01/27 05:03:25 deraadt Exp $ */
|
||||
/* $OpenBSD: fsck.h,v 1.35 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: fsck.h,v 1.13 1996/10/11 20:15:46 thorpej Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -229,7 +229,6 @@ extern char yflag; /* assume a yes response */
|
|||
extern daddr_t bflag; /* location of alternate super block */
|
||||
extern int debug; /* output debugging info */
|
||||
extern int cvtlevel; /* convert to newer file system format */
|
||||
extern char usedsoftdep; /* just fix soft dependency inconsistencies */
|
||||
extern int preen; /* just fix normal inconsistencies */
|
||||
extern char resolved; /* cleared if unresolved changes => not clean */
|
||||
extern char havesb; /* superblock has been read */
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: main.c,v 1.54 2023/03/08 04:43:06 guenther Exp $ */
|
||||
/* $OpenBSD: main.c,v 1.55 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: main.c,v 1.22 1996/10/11 20:15:48 thorpej Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -77,7 +77,6 @@ char yflag; /* assume a yes response */
|
|||
daddr_t bflag; /* location of alternate super block */
|
||||
int debug; /* output debugging info */
|
||||
int cvtlevel; /* convert to newer file system format */
|
||||
char usedsoftdep; /* just fix soft dependency inconsistencies */
|
||||
int preen; /* just fix normal inconsistencies */
|
||||
char resolved; /* cleared if unresolved changes => not clean */
|
||||
char havesb; /* superblock has been read */
|
||||
|
@ -257,7 +256,7 @@ checkfilesys(char *filesys, char *mntpt, long auxdata, int child)
|
|||
* 1b: locate first references to duplicates, if any
|
||||
*/
|
||||
if (duplist) {
|
||||
if (preen || usedsoftdep)
|
||||
if (preen)
|
||||
pfatal("INTERNAL ERROR: dups with -p");
|
||||
printf("** Phase 1b - Rescan For More DUPS\n");
|
||||
pass1b();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pass1.c,v 1.48 2024/01/09 03:16:00 guenther Exp $ */
|
||||
/* $OpenBSD: pass1.c,v 1.49 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: pass1.c,v 1.16 1996/09/27 22:45:15 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -110,31 +110,6 @@ pass1(void)
|
|||
} else
|
||||
inosused = sblock.fs_ipg;
|
||||
|
||||
/*
|
||||
* If we are using soft updates, then we can trust the
|
||||
* cylinder group inode allocation maps to tell us which
|
||||
* inodes are allocated. We will scan the used inode map
|
||||
* to find the inodes that are really in use, and then
|
||||
* read only those inodes in from disk.
|
||||
*/
|
||||
if (preen && usedsoftdep) {
|
||||
cp = &cg_inosused(cgp)[(inosused - 1) / CHAR_BIT];
|
||||
for ( ; inosused != 0; cp--) {
|
||||
if (*cp == 0) {
|
||||
if (inosused > CHAR_BIT)
|
||||
inosused -= CHAR_BIT;
|
||||
else
|
||||
inosused = 0;
|
||||
continue;
|
||||
}
|
||||
for (i = 1 << (CHAR_BIT - 1); i > 0; i >>= 1) {
|
||||
if (*cp & i)
|
||||
break;
|
||||
inosused--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Allocate inoinfo structures for the allocated inodes.
|
||||
*/
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pass2.c,v 1.38 2024/01/09 03:16:00 guenther Exp $ */
|
||||
/* $OpenBSD: pass2.c,v 1.39 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: pass2.c,v 1.17 1996/09/27 22:45:15 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -162,14 +162,9 @@ pass2(void)
|
|||
} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
|
||||
getpathname(pathbuf, sizeof pathbuf,
|
||||
inp->i_number, inp->i_number);
|
||||
if (usedsoftdep)
|
||||
pfatal("%s %s: LENGTH %zu NOT MULTIPLE of %d",
|
||||
"DIRECTORY", pathbuf, inp->i_isize,
|
||||
DIRBLKSIZ);
|
||||
else
|
||||
pwarn("%s %s: LENGTH %zu NOT MULTIPLE OF %d",
|
||||
"DIRECTORY", pathbuf, inp->i_isize,
|
||||
DIRBLKSIZ);
|
||||
pwarn("%s %s: LENGTH %zu NOT MULTIPLE OF %d",
|
||||
"DIRECTORY", pathbuf, inp->i_isize,
|
||||
DIRBLKSIZ);
|
||||
if (preen)
|
||||
printf(" (ADJUSTED)\n");
|
||||
inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
|
||||
|
@ -403,7 +398,7 @@ again:
|
|||
break;
|
||||
if (GET_ISTATE(dirp->d_ino) == FCLEAR)
|
||||
errmsg = "DUP/BAD";
|
||||
else if (!preen && !usedsoftdep)
|
||||
else if (!preen)
|
||||
errmsg = "ZERO LENGTH DIRECTORY";
|
||||
else {
|
||||
n = 1;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pass5.c,v 1.50 2020/07/13 06:52:53 otto Exp $ */
|
||||
/* $OpenBSD: pass5.c,v 1.51 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: pass5.c,v 1.16 1996/09/27 22:45:18 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -333,34 +333,6 @@ pass5(void)
|
|||
memcpy(cg, newcg, (size_t)basesize);
|
||||
dirty(cgbp);
|
||||
}
|
||||
if (usedsoftdep) {
|
||||
for (i = 0; i < inomapsize; i++) {
|
||||
j = cg_inosused(newcg)[i];
|
||||
if ((cg_inosused(cg)[i] & j) == j)
|
||||
continue;
|
||||
for (k = 0; k < NBBY; k++) {
|
||||
if ((j & (1 << k)) == 0)
|
||||
continue;
|
||||
if (cg_inosused(cg)[i] & (1 << k))
|
||||
continue;
|
||||
pwarn("ALLOCATED INODE %llu MARKED FREE\n",
|
||||
((ino_t)c * fs->fs_ipg + i * 8) + k);
|
||||
}
|
||||
}
|
||||
for (i = 0; i < blkmapsize; i++) {
|
||||
j = cg_blksfree(cg)[i];
|
||||
if ((cg_blksfree(newcg)[i] & j) == j)
|
||||
continue;
|
||||
for (k = 0; k < NBBY; k++) {
|
||||
if ((j & (1 << k)) == 0)
|
||||
continue;
|
||||
if (cg_blksfree(newcg)[i] & (1 << k))
|
||||
continue;
|
||||
pwarn("ALLOCATED FRAG %lld MARKED FREE\n",
|
||||
((long long)c * fs->fs_fpg + i * 8) + k);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (memcmp(cg_inosused(newcg), cg_inosused(cg),
|
||||
mapsize) != 0 &&
|
||||
dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: setup.c,v 1.69 2022/09/01 13:37:57 krw Exp $ */
|
||||
/* $OpenBSD: setup.c,v 1.70 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: setup.c,v 1.27 1996/09/27 22:45:19 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -450,10 +450,6 @@ found:
|
|||
goto badsblabel;
|
||||
}
|
||||
bufinit();
|
||||
if (sblock.fs_flags & FS_DOSOFTDEP)
|
||||
usedsoftdep = 1;
|
||||
else
|
||||
usedsoftdep = 0;
|
||||
return (1);
|
||||
|
||||
badsblabel:
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: growfs.c,v 1.55 2022/12/04 23:50:46 cheloha Exp $ */
|
||||
/* $OpenBSD: growfs.c,v 1.56 2024/02/03 18:51:57 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
|
||||
* Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
|
||||
|
@ -202,8 +202,6 @@ growfs(int fsi, int fso, unsigned int Nflag)
|
|||
printf("\tusing %u cylinder groups of %.2fMB, %d blks, %u inodes.\n",
|
||||
sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
|
||||
sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
|
||||
if (sblock.fs_flags & FS_DOSOFTDEP)
|
||||
printf("\twith soft updates\n");
|
||||
#undef B2MBFACTOR
|
||||
|
||||
/*
|
||||
|
@ -282,9 +280,6 @@ growfs(int fsi, int fso, unsigned int Nflag)
|
|||
sblock.fs_cgrotor = 0;
|
||||
sblock.fs_state = 0;
|
||||
memset(&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
|
||||
sblock.fs_flags &= FS_DOSOFTDEP;
|
||||
if (sblock.fs_magic == FS_UFS1_MAGIC)
|
||||
sblock.fs_ffs1_flags &= FS_DOSOFTDEP;
|
||||
|
||||
/*
|
||||
* XXX
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: policy.c,v 1.97 2023/11/10 08:03:02 tobhe Exp $ */
|
||||
/* $OpenBSD: policy.c,v 1.98 2024/02/03 00:54:14 jsg Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2020-2021 Tobias Heider <tobhe@openbsd.org>
|
||||
|
@ -1091,7 +1091,7 @@ proposals_match(struct iked_proposal *local, struct iked_proposal *peer,
|
|||
|
||||
for (i = 0; i < peer->prop_nxforms; i++) {
|
||||
tpeer = peer->prop_xforms + i;
|
||||
if (tpeer->xform_type > IKEV2_XFORMTYPE_MAX)
|
||||
if (tpeer->xform_type >= IKEV2_XFORMTYPE_MAX)
|
||||
continue;
|
||||
if (noauth && tpeer->xform_type == IKEV2_XFORMTYPE_INTEGR)
|
||||
return (0);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: quotacheck.c,v 1.41 2019/06/28 13:32:45 deraadt Exp $ */
|
||||
/* $OpenBSD: quotacheck.c,v 1.42 2024/02/03 18:51:57 beck Exp $ */
|
||||
/* $NetBSD: quotacheck.c,v 1.12 1996/03/30 22:34:25 mark Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -303,30 +303,6 @@ chkquota(const char *vfstype, const char *fsname, const char *mntpt,
|
|||
inosused = cgblk.cg_initediblk;
|
||||
else
|
||||
inosused = sblock.fs_ipg;
|
||||
/*
|
||||
* If we are using soft updates, then we can trust the
|
||||
* cylinder group inode allocation maps to tell us which
|
||||
* inodes are allocated. We will scan the used inode map
|
||||
* to find the inodes that are really in use, and then
|
||||
* read only those inodes in from disk.
|
||||
*/
|
||||
if (sblock.fs_flags & FS_DOSOFTDEP) {
|
||||
if (!cg_chkmagic(&cgblk))
|
||||
errx(1, "CG %d: BAD MAGIC NUMBER\n", cg);
|
||||
cp = &cg_inosused(&cgblk)[(inosused - 1) / CHAR_BIT];
|
||||
for ( ; inosused > 0; inosused -= CHAR_BIT, cp--) {
|
||||
if (*cp == 0)
|
||||
continue;
|
||||
for (i = 1 << (CHAR_BIT - 1); i > 0; i >>= 1) {
|
||||
if (*cp & i)
|
||||
break;
|
||||
inosused--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (inosused <= 0)
|
||||
continue;
|
||||
}
|
||||
for (i = 0; i < inosused; i++, ino++) {
|
||||
if ((dp = getnextinode(ino)) == NULL ||
|
||||
ino < ROOTINO ||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: engine.c,v 1.86 2023/12/14 09:58:59 claudio Exp $ */
|
||||
/* $OpenBSD: engine.c,v 1.87 2024/02/03 18:30:17 florian Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2017 Florian Obser <florian@openbsd.org>
|
||||
|
@ -1272,7 +1272,7 @@ request_solicitation(struct slaacd_iface *iface)
|
|||
clock_gettime(CLOCK_MONOTONIC, &now);
|
||||
timespecsub(&now, &iface->last_sol, &diff);
|
||||
if (timespeccmp(&diff, &sol_delay, <)) {
|
||||
log_warnx("last solicitation less then %d seconds ago",
|
||||
log_debug("last solicitation less than %d seconds ago",
|
||||
RTR_SOLICITATION_INTERVAL);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
.\" $OpenBSD: fs.5,v 1.19 2015/09/10 17:55:21 schwarze Exp $
|
||||
.\" $OpenBSD: fs.5,v 1.20 2024/02/03 18:51:57 beck Exp $
|
||||
.\" $NetBSD: fs.5,v 1.3 1994/11/30 19:31:17 jtc Exp $
|
||||
.\"
|
||||
.\" Copyright (c) 1983, 1991, 1993
|
||||
|
@ -30,7 +30,7 @@
|
|||
.\"
|
||||
.\" @(#)fs.5 8.2 (Berkeley) 4/19/94
|
||||
.\"
|
||||
.Dd $Mdocdate: September 10 2015 $
|
||||
.Dd $Mdocdate: February 3 2024 $
|
||||
.Dt FS 5
|
||||
.Os
|
||||
.Sh NAME
|
||||
|
@ -276,9 +276,7 @@ The
|
|||
.Va fs_flags
|
||||
element specifies how the filesystem was mounted:
|
||||
.Pp
|
||||
.Bl -tag -width FS_DOSOFTDEP -offset ind -compact
|
||||
.It Dv FS_DOSOFTDEP
|
||||
The filesystem was mounted using soft dependencies.
|
||||
.Bl -tag -width FS_UNCLEAN -offset ind -compact
|
||||
.It Dv FS_UNCLEAN
|
||||
The filesystem was mounted uncleanly.
|
||||
.El
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: cacheinfo.c,v 1.11 2022/07/12 04:46:00 jsg Exp $ */
|
||||
/* $OpenBSD: cacheinfo.c,v 1.12 2024/02/03 09:53:15 jsg Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2022 Jonathan Gray <jsg@openbsd.org>
|
||||
|
@ -43,10 +43,7 @@ amd64_print_l1_cacheinfo(struct cpu_info *ci)
|
|||
|
||||
printf("%s: ", ci->ci_dev->dv_xname);
|
||||
|
||||
if (totalsize < 1024)
|
||||
printf("%dKB ", totalsize);
|
||||
else
|
||||
printf("%dMB ", totalsize >> 10);
|
||||
printf("%dKB ", totalsize);
|
||||
printf("%db/line ", linesize);
|
||||
|
||||
switch (ways) {
|
||||
|
@ -70,10 +67,7 @@ amd64_print_l1_cacheinfo(struct cpu_info *ci)
|
|||
ways = (edx >> 16) & 0xff;
|
||||
totalsize = (edx >> 24) & 0xff; /* KB */
|
||||
|
||||
if (totalsize < 1024)
|
||||
printf("%dKB ", totalsize);
|
||||
else
|
||||
printf("%dMB ", totalsize >> 10);
|
||||
printf("%dKB ", totalsize);
|
||||
printf("%db/line ", linesize);
|
||||
|
||||
switch (ways) {
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: cpu.c,v 1.177 2023/11/22 18:50:10 bluhm Exp $ */
|
||||
/* $OpenBSD: cpu.c,v 1.178 2024/02/03 16:21:22 deraadt Exp $ */
|
||||
/* $NetBSD: cpu.c,v 1.1 2003/04/26 18:39:26 fvdl Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -163,6 +163,7 @@ int cpu_apmi_edx = 0; /* cpuid(0x80000007).edx */
|
|||
int ecpu_ecxfeature = 0; /* cpuid(0x80000001).ecx */
|
||||
int cpu_meltdown = 0;
|
||||
int cpu_use_xsaves = 0;
|
||||
int need_retpoline = 1; /* most systems need retpoline */
|
||||
|
||||
void
|
||||
replacesmap(void)
|
||||
|
@ -232,9 +233,11 @@ replacemeltdown(void)
|
|||
if (ibrs == 2 || (ci->ci_feature_sefflags_edx & SEFF0EDX_IBT)) {
|
||||
extern const char _jmprax, _jmpr11, _jmpr13;
|
||||
extern const short _jmprax_len, _jmpr11_len, _jmpr13_len;
|
||||
|
||||
codepatch_replace(CPTAG_RETPOLINE_RAX, &_jmprax, _jmprax_len);
|
||||
codepatch_replace(CPTAG_RETPOLINE_R11, &_jmpr11, _jmpr11_len);
|
||||
codepatch_replace(CPTAG_RETPOLINE_R13, &_jmpr13, _jmpr13_len);
|
||||
need_retpoline = 0;
|
||||
}
|
||||
|
||||
if (!cpu_meltdown)
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: machdep.c,v 1.289 2024/01/19 18:38:16 kettenis Exp $ */
|
||||
/* $OpenBSD: machdep.c,v 1.290 2024/02/03 16:21:22 deraadt Exp $ */
|
||||
/* $NetBSD: machdep.c,v 1.3 2003/05/07 22:58:18 fvdl Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -486,6 +486,7 @@ bios_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
|
|||
|
||||
extern int tsc_is_invariant;
|
||||
extern int amd64_has_xcrypt;
|
||||
extern int need_retpoline;
|
||||
|
||||
const struct sysctl_bounded_args cpuctl_vars[] = {
|
||||
{ CPU_LIDACTION, &lid_action, 0, 2 },
|
||||
|
@ -494,6 +495,7 @@ const struct sysctl_bounded_args cpuctl_vars[] = {
|
|||
{ CPU_CPUFEATURE, &cpu_feature, SYSCTL_INT_READONLY },
|
||||
{ CPU_XCRYPT, &amd64_has_xcrypt, SYSCTL_INT_READONLY },
|
||||
{ CPU_INVARIANTTSC, &tsc_is_invariant, SYSCTL_INT_READONLY },
|
||||
{ CPU_RETPOLINE, &need_retpoline, SYSCTL_INT_READONLY },
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: cpu.h,v 1.160 2024/01/24 19:23:39 cheloha Exp $ */
|
||||
/* $OpenBSD: cpu.h,v 1.161 2024/02/03 16:21:22 deraadt Exp $ */
|
||||
/* $NetBSD: cpu.h,v 1.1 2003/04/26 18:39:39 fvdl Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -481,7 +481,8 @@ void mp_setperf_init(void);
|
|||
#define CPU_TSCFREQ 16 /* TSC frequency */
|
||||
#define CPU_INVARIANTTSC 17 /* has invariant TSC */
|
||||
#define CPU_PWRACTION 18 /* action caused by power button */
|
||||
#define CPU_MAXID 19 /* number of valid machdep ids */
|
||||
#define CPU_RETPOLINE 19 /* cpu requires retpoline pattern */
|
||||
#define CPU_MAXID 20 /* number of valid machdep ids */
|
||||
|
||||
#define CTL_MACHDEP_NAMES { \
|
||||
{ 0, 0 }, \
|
||||
|
@ -503,6 +504,7 @@ void mp_setperf_init(void);
|
|||
{ "tscfreq", CTLTYPE_QUAD }, \
|
||||
{ "invarianttsc", CTLTYPE_INT }, \
|
||||
{ "pwraction", CTLTYPE_INT }, \
|
||||
{ "retpoline", CTLTYPE_INT }, \
|
||||
}
|
||||
|
||||
#endif /* !_MACHINE_CPU_H_ */
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: acpipci.c,v 1.41 2023/09/16 23:25:16 jmatthew Exp $ */
|
||||
/* $OpenBSD: acpipci.c,v 1.42 2024/02/03 10:37:25 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018 Mark Kettenis
|
||||
*
|
||||
|
@ -207,6 +207,7 @@ acpipci_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc->pc_intr_v = sc;
|
||||
sc->sc_pc->pc_intr_map = acpipci_intr_map;
|
||||
sc->sc_pc->pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc->pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc->pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc->pc_intr_string = acpipci_intr_string;
|
||||
sc->sc_pc->pc_intr_establish = acpipci_intr_establish;
|
||||
|
@ -629,7 +630,7 @@ acpipci_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
if (ih.ih_type != PCI_INTX) {
|
||||
struct interrupt_controller *ic = sc->sc_msi_ic;
|
||||
bus_dma_segment_t seg;
|
||||
uint64_t addr, data;
|
||||
uint64_t addr = 0, data;
|
||||
|
||||
KASSERT(ic);
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: agintc.c,v 1.54 2023/09/22 01:10:43 jsg Exp $ */
|
||||
/* $OpenBSD: agintc.c,v 1.55 2024/02/03 10:37:25 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2007, 2009, 2011, 2017 Dale Rahn <drahn@dalerahn.com>
|
||||
* Copyright (c) 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
|
@ -1540,7 +1540,7 @@ struct agintc_msi_device {
|
|||
LIST_ENTRY(agintc_msi_device) md_list;
|
||||
|
||||
uint32_t md_deviceid;
|
||||
uint32_t md_eventid;
|
||||
uint32_t md_events;
|
||||
struct agintc_dmamem *md_itt;
|
||||
};
|
||||
|
||||
|
@ -1949,7 +1949,15 @@ agintc_intr_establish_msi(void *self, uint64_t *addr, uint64_t *data,
|
|||
if (md == NULL)
|
||||
return NULL;
|
||||
|
||||
eventid = md->md_eventid++;
|
||||
eventid = *addr;
|
||||
if (eventid > 0 && (md->md_events & (1U << eventid)))
|
||||
return NULL;
|
||||
for (; eventid < 32; eventid++) {
|
||||
if ((md->md_events & (1U << eventid)) == 0) {
|
||||
md->md_events |= (1U << eventid);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (eventid >= 32)
|
||||
return NULL;
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: aplpcie.c,v 1.18 2023/12/28 13:32:56 kettenis Exp $ */
|
||||
/* $OpenBSD: aplpcie.c,v 1.19 2024/02/03 10:37:25 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2021 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
@ -405,6 +405,7 @@ aplpcie_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = aplpcie_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = aplpcie_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = aplpcie_intr_establish;
|
||||
|
@ -939,6 +940,7 @@ aplpcie_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
if (ih.ih_type != PCI_INTX) {
|
||||
uint64_t addr, data;
|
||||
|
||||
addr = data = 0;
|
||||
cookie = fdt_intr_establish_msi_cpu(sc->sc_node, &addr,
|
||||
&data, level, ci, func, arg, name);
|
||||
if (cookie == NULL)
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pci_machdep.c,v 1.5 2021/03/22 20:30:21 patrick Exp $ */
|
||||
/* $OpenBSD: pci_machdep.c,v 1.6 2024/02/03 10:37:25 kettenis Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2019 Mark Kettenis <kettenis@openbsd.org>
|
||||
|
@ -24,16 +24,45 @@
|
|||
#include <dev/pci/pcivar.h>
|
||||
#include <dev/pci/pcireg.h>
|
||||
|
||||
int
|
||||
pci_intr_enable_msivec(struct pci_attach_args *pa, int num_vec)
|
||||
{
|
||||
pci_chipset_tag_t pc = pa->pa_pc;
|
||||
pcitag_t tag = pa->pa_tag;
|
||||
pcireg_t reg;
|
||||
int mmc, mme, off;
|
||||
|
||||
if ((pa->pa_flags & PCI_FLAGS_MSI_ENABLED) == 0 ||
|
||||
pci_get_capability(pc, tag, PCI_CAP_MSI, &off, ®) == 0)
|
||||
return 1;
|
||||
|
||||
mmc = ((reg & PCI_MSI_MC_MMC_MASK) >> PCI_MSI_MC_MMC_SHIFT);
|
||||
if (num_vec > (1 << mmc))
|
||||
return 1;
|
||||
|
||||
mme = ((reg & PCI_MSI_MC_MME_MASK) >> PCI_MSI_MC_MME_SHIFT);
|
||||
while ((1 << mme) < num_vec)
|
||||
mme++;
|
||||
reg &= ~PCI_MSI_MC_MME_MASK;
|
||||
reg |= (mme << PCI_MSI_MC_MME_SHIFT);
|
||||
pci_conf_write(pc, tag, off, reg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
pci_msi_enable(pci_chipset_tag_t pc, pcitag_t tag,
|
||||
bus_addr_t addr, uint32_t data)
|
||||
{
|
||||
pcireg_t reg;
|
||||
int off;
|
||||
int mme, off;
|
||||
|
||||
if (pci_get_capability(pc, tag, PCI_CAP_MSI, &off, ®) == 0)
|
||||
panic("%s: no msi capability", __func__);
|
||||
|
||||
mme = ((reg & PCI_MSI_MC_MME_MASK) >> PCI_MSI_MC_MME_SHIFT);
|
||||
data &= ~((1 << mme) - 1);
|
||||
|
||||
if (reg & PCI_MSI_MC_C64) {
|
||||
pci_conf_write(pc, tag, off + PCI_MSI_MA, addr);
|
||||
pci_conf_write(pc, tag, off + PCI_MSI_MAU32, addr >> 32);
|
||||
|
@ -128,6 +157,33 @@ _pci_intr_map_msi(struct pci_attach_args *pa, pci_intr_handle_t *ihp)
|
|||
|
||||
ihp->ih_pc = pa->pa_pc;
|
||||
ihp->ih_tag = pa->pa_tag;
|
||||
ihp->ih_intrpin = 0;
|
||||
ihp->ih_type = PCI_MSI;
|
||||
ihp->ih_dmat = pa->pa_dmat;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
_pci_intr_map_msivec(struct pci_attach_args *pa, int vec,
|
||||
pci_intr_handle_t *ihp)
|
||||
{
|
||||
pci_chipset_tag_t pc = pa->pa_pc;
|
||||
pcitag_t tag = pa->pa_tag;
|
||||
pcireg_t reg;
|
||||
int mme, off;
|
||||
|
||||
if ((pa->pa_flags & PCI_FLAGS_MSIVEC_ENABLED) == 0 ||
|
||||
pci_get_capability(pc, tag, PCI_CAP_MSI, &off, ®) == 0)
|
||||
return -1;
|
||||
|
||||
mme = ((reg & PCI_MSI_MC_MME_MASK) >> PCI_MSI_MC_MME_SHIFT);
|
||||
if (vec >= (1 << mme))
|
||||
return -1;
|
||||
|
||||
ihp->ih_pc = pa->pa_pc;
|
||||
ihp->ih_tag = pa->pa_tag;
|
||||
ihp->ih_intrpin = vec;
|
||||
ihp->ih_type = PCI_MSI;
|
||||
ihp->ih_dmat = pa->pa_dmat;
|
||||
|
||||
|
@ -164,4 +220,3 @@ _pci_intr_map_msix(struct pci_attach_args *pa, int vec,
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pci_machdep.h,v 1.11 2021/06/11 12:23:52 kettenis Exp $ */
|
||||
/* $OpenBSD: pci_machdep.h,v 1.12 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2003-2004 Opsycon AB (www.opsycon.se / www.opsycon.com)
|
||||
|
@ -70,6 +70,8 @@ struct machine_pci_chipset {
|
|||
pci_intr_handle_t *);
|
||||
int (*pc_intr_map_msi)(struct pci_attach_args *,
|
||||
pci_intr_handle_t *);
|
||||
int (*pc_intr_map_msivec)(struct pci_attach_args *,
|
||||
int, pci_intr_handle_t *);
|
||||
int (*pc_intr_map_msix)(struct pci_attach_args *,
|
||||
int, pci_intr_handle_t *);
|
||||
const char *(*pc_intr_string)(void *, pci_intr_handle_t);
|
||||
|
@ -102,6 +104,8 @@ struct machine_pci_chipset {
|
|||
(*(c)->pa_pc->pc_intr_map)((c), (ihp))
|
||||
#define pci_intr_map_msi(c, ihp) \
|
||||
(*(c)->pa_pc->pc_intr_map_msi)((c), (ihp))
|
||||
#define pci_intr_map_msivec(c, vec, ihp) \
|
||||
(*(c)->pa_pc->pc_intr_map_msivec)((c), (vec), (ihp))
|
||||
#define pci_intr_map_msix(c, vec, ihp) \
|
||||
(*(c)->pa_pc->pc_intr_map_msix)((c), (vec), (ihp))
|
||||
#define pci_intr_string(c, ih) \
|
||||
|
@ -123,10 +127,14 @@ struct machine_pci_chipset {
|
|||
void pci_mcfg_init(bus_space_tag_t, bus_addr_t, int, int, int);
|
||||
pci_chipset_tag_t pci_lookup_segment(int);
|
||||
|
||||
int pci_intr_enable_msivec(struct pci_attach_args *, int);
|
||||
|
||||
void pci_msi_enable(pci_chipset_tag_t, pcitag_t, bus_addr_t, uint32_t);
|
||||
void pci_msix_enable(pci_chipset_tag_t, pcitag_t, bus_space_tag_t,
|
||||
int, bus_addr_t, uint32_t);
|
||||
int _pci_intr_map_msi(struct pci_attach_args *, pci_intr_handle_t *);
|
||||
int _pci_intr_map_msivec(struct pci_attach_args *, int,
|
||||
pci_intr_handle_t *);
|
||||
int _pci_intr_map_msix(struct pci_attach_args *, int, pci_intr_handle_t *);
|
||||
|
||||
#define __HAVE_PCI_MSIX
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
# $OpenBSD: files,v 1.729 2024/01/01 18:25:50 kettenis Exp $
|
||||
# $OpenBSD: files,v 1.730 2024/02/03 18:51:57 beck Exp $
|
||||
# $NetBSD: files,v 1.87 1996/05/19 17:17:50 jonathan Exp $
|
||||
|
||||
# @(#)files.newconf 7.5 (Berkeley) 5/10/93
|
||||
|
@ -960,11 +960,9 @@ file ufs/ffs/ffs_alloc.c ffs | mfs
|
|||
file ufs/ffs/ffs_balloc.c ffs | mfs
|
||||
file ufs/ffs/ffs_inode.c ffs | mfs
|
||||
file ufs/ffs/ffs_subr.c ffs | mfs
|
||||
file ufs/ffs/ffs_softdep_stub.c ffs | mfs
|
||||
file ufs/ffs/ffs_tables.c ffs | mfs
|
||||
file ufs/ffs/ffs_vfsops.c ffs | mfs
|
||||
file ufs/ffs/ffs_vnops.c ffs | mfs
|
||||
file ufs/ffs/ffs_softdep.c ffs_softupdates
|
||||
file ufs/mfs/mfs_vfsops.c mfs
|
||||
file ufs/mfs/mfs_vnops.c mfs
|
||||
file ufs/ufs/ufs_bmap.c ffs | mfs | ext2fs
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: db_interface.h,v 1.26 2023/07/02 19:02:27 cheloha Exp $ */
|
||||
/* $OpenBSD: db_interface.h,v 1.27 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: db_interface.h,v 1.1 1996/02/05 01:57:03 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -78,11 +78,6 @@ void nfs_node_print(void *, int, int (*)(const char *, ...));
|
|||
/* uvm/uvm_swap.c */
|
||||
void swap_print_all(int (*)(const char *, ...));
|
||||
|
||||
/* ufs/ffs/ffs_softdep.c */
|
||||
struct worklist;
|
||||
void worklist_print(struct worklist *, int, int (*)(const char *, ...));
|
||||
void softdep_print(struct buf *, int, int (*)(const char *, ...));
|
||||
|
||||
/* arch/<arch>/<arch>/db_interface.c */
|
||||
void db_machine_init(void);
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bcm2711_pcie.c,v 1.11 2022/04/06 18:59:28 naddy Exp $ */
|
||||
/* $OpenBSD: bcm2711_pcie.c,v 1.12 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2020 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
@ -299,6 +299,7 @@ bcmpcie_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = bcmpcie_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = bcmpcie_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = bcmpcie_intr_establish;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dwpcie.c,v 1.50 2023/09/21 19:39:41 patrick Exp $ */
|
||||
/* $OpenBSD: dwpcie.c,v 1.51 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
@ -711,6 +711,7 @@ dwpcie_attach_deferred(struct device *self)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = dwpcie_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = dwpcie_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = dwpcie_intr_establish;
|
||||
|
@ -729,6 +730,8 @@ dwpcie_attach_deferred(struct device *self)
|
|||
OF_getproplen(sc->sc_node, "msi-map") > 0 ||
|
||||
sc->sc_msi_addr)
|
||||
pba.pba_flags |= PCI_FLAGS_MSI_ENABLED;
|
||||
if (OF_getproplen(sc->sc_node, "msi-map") > 0)
|
||||
pba.pba_flags |= PCI_FLAGS_MSIVEC_ENABLED;
|
||||
|
||||
/* XXX No working MSI on RK3588 yet. */
|
||||
if (OF_is_compatible(sc->sc_node, "rockchip,rk3588-pcie"))
|
||||
|
@ -1835,6 +1838,8 @@ dwpcie_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
uint64_t addr, data;
|
||||
|
||||
if (sc->sc_msi_addr) {
|
||||
if (ih.ih_type == PCI_MSI && ih.ih_intrpin > 0)
|
||||
return NULL;
|
||||
dm = dwpcie_msi_establish(sc, level, func, arg, name);
|
||||
if (dm == NULL)
|
||||
return NULL;
|
||||
|
@ -1845,6 +1850,7 @@ dwpcie_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
* Assume hardware passes Requester ID as
|
||||
* sideband data.
|
||||
*/
|
||||
addr = ih.ih_intrpin;
|
||||
data = pci_requester_id(ih.ih_pc, ih.ih_tag);
|
||||
cookie = fdt_intr_establish_msi_cpu(sc->sc_node, &addr,
|
||||
&data, level, ci, func, arg, (void *)name);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: mvkpcie.c,v 1.13 2022/04/06 18:59:28 naddy Exp $ */
|
||||
/* $OpenBSD: mvkpcie.c,v 1.14 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
* Copyright (c) 2020 Patrick Wildt <patrick@blueri.se>
|
||||
|
@ -528,6 +528,7 @@ mvkpcie_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = mvkpcie_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = mvkpcie_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = mvkpcie_intr_establish;
|
||||
|
@ -783,7 +784,7 @@ mvkpcie_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
KASSERT(ih.ih_type != PCI_NONE);
|
||||
|
||||
if (ih.ih_type != PCI_INTX) {
|
||||
uint64_t addr, data;
|
||||
uint64_t addr = 0, data;
|
||||
|
||||
/* Assume hardware passes Requester ID as sideband data. */
|
||||
data = pci_requester_id(ih.ih_pc, ih.ih_tag);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pciecam.c,v 1.4 2022/04/06 18:59:28 naddy Exp $ */
|
||||
/* $OpenBSD: pciecam.c,v 1.5 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2013,2017 Patrick Wildt <patrick@blueri.se>
|
||||
*
|
||||
|
@ -245,6 +245,7 @@ pciecam_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = pciecam_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = pciecam_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = pciecam_intr_establish;
|
||||
|
@ -391,7 +392,7 @@ pciecam_intr_establish(void *self, pci_intr_handle_t ih, int level,
|
|||
KASSERT(ih.ih_type != PCI_NONE);
|
||||
|
||||
if (ih.ih_type != PCI_INTX) {
|
||||
uint64_t addr, data;
|
||||
uint64_t addr = 0, data;
|
||||
|
||||
/* Assume hardware passes Requester ID as sideband data. */
|
||||
data = pci_requester_id(ih.ih_pc, ih.ih_tag);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: rkpcie.c,v 1.17 2023/04/11 00:45:08 jsg Exp $ */
|
||||
/* $OpenBSD: rkpcie.c,v 1.18 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2018 Mark Kettenis <kettenis@openbsd.org>
|
||||
*
|
||||
|
@ -372,6 +372,7 @@ rkpcie_attach(struct device *parent, struct device *self, void *aux)
|
|||
sc->sc_pc.pc_intr_v = sc;
|
||||
sc->sc_pc.pc_intr_map = rkpcie_intr_map;
|
||||
sc->sc_pc.pc_intr_map_msi = _pci_intr_map_msi;
|
||||
sc->sc_pc.pc_intr_map_msivec = _pci_intr_map_msivec;
|
||||
sc->sc_pc.pc_intr_map_msix = _pci_intr_map_msix;
|
||||
sc->sc_pc.pc_intr_string = rkpcie_intr_string;
|
||||
sc->sc_pc.pc_intr_establish = rkpcie_intr_establish;
|
||||
|
@ -605,7 +606,7 @@ rkpcie_intr_establish(void *v, pci_intr_handle_t ih, int level,
|
|||
KASSERT(ih.ih_type != PCI_NONE);
|
||||
|
||||
if (ih.ih_type != PCI_INTX) {
|
||||
uint64_t addr, data;
|
||||
uint64_t addr = 0, data;
|
||||
|
||||
/* Assume hardware passes Requester ID as sideband data. */
|
||||
data = pci_requester_id(ih.ih_pc, ih.ih_tag);
|
||||
|
|
533
sys/dev/ic/qwx.c
533
sys/dev/ic/qwx.c
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: qwx.c,v 1.14 2024/02/02 15:44:19 stsp Exp $ */
|
||||
/* $OpenBSD: qwx.c,v 1.16 2024/02/03 20:07:19 kettenis Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright 2023 Stefan Sperling <stsp@openbsd.org>
|
||||
|
@ -68,6 +68,10 @@
|
|||
#include <machine/bus.h>
|
||||
#include <machine/intr.h>
|
||||
|
||||
#ifdef __HAVE_FDT
|
||||
#include <dev/ofw/openfirm.h>
|
||||
#endif
|
||||
|
||||
#include <net/if.h>
|
||||
#include <net/if_media.h>
|
||||
|
||||
|
@ -136,6 +140,8 @@ int qwx_mac_start(struct qwx_softc *);
|
|||
void qwx_mac_scan_finish(struct qwx_softc *);
|
||||
int qwx_mac_mgmt_tx_wmi(struct qwx_softc *, struct qwx_vif *, uint8_t,
|
||||
struct mbuf *);
|
||||
int qwx_dp_tx(struct qwx_softc *, struct qwx_vif *, uint8_t,
|
||||
struct ieee80211_node *, struct mbuf *);
|
||||
int qwx_dp_tx_send_reo_cmd(struct qwx_softc *, struct dp_rx_tid *,
|
||||
enum hal_reo_cmd_type , struct ath11k_hal_reo_cmd *,
|
||||
void (*func)(struct qwx_dp *, void *, enum hal_reo_cmd_status));
|
||||
|
@ -358,9 +364,7 @@ qwx_tx(struct qwx_softc *sc, struct mbuf *m, struct ieee80211_node *ni)
|
|||
if (frame_type == IEEE80211_FC0_TYPE_MGT)
|
||||
return qwx_mac_mgmt_tx_wmi(sc, arvif, pdev_id, m);
|
||||
|
||||
printf("%s: not implemented\n", __func__);
|
||||
m_freem(m);
|
||||
return ENOTSUP;
|
||||
return qwx_dp_tx(sc, arvif, pdev_id, ni, m);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -1455,10 +1459,38 @@ qwx_hw_wcn6855_rx_desc_mpdu_start_addr2(struct hal_rx_desc *desc)
|
|||
return desc->u.wcn6855.mpdu_start.addr2;
|
||||
}
|
||||
|
||||
/* Map from pdev index to hw mac index */
|
||||
uint8_t
|
||||
qwx_hw_ipq8074_mac_from_pdev_id(int pdev_idx)
|
||||
{
|
||||
switch (pdev_idx) {
|
||||
case 0:
|
||||
return 0;
|
||||
case 1:
|
||||
return 2;
|
||||
case 2:
|
||||
return 1;
|
||||
default:
|
||||
return ATH11K_INVALID_HW_MAC_ID;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t qwx_hw_ipq6018_mac_from_pdev_id(int pdev_idx)
|
||||
{
|
||||
return pdev_idx;
|
||||
}
|
||||
|
||||
static inline int
|
||||
qwx_hw_get_mac_from_pdev_id(struct qwx_softc *sc, int pdev_idx)
|
||||
{
|
||||
if (sc->hw_params.hw_ops->get_hw_mac_from_pdev_id)
|
||||
return sc->hw_params.hw_ops->get_hw_mac_from_pdev_id(pdev_idx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const struct ath11k_hw_ops ipq8074_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq8074_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq8074_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_ipq8074,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_ipq8074,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_ipq8074,
|
||||
|
@ -1510,9 +1542,7 @@ const struct ath11k_hw_ops ipq8074_ops = {
|
|||
};
|
||||
|
||||
const struct ath11k_hw_ops ipq6018_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq6018_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq6018_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_ipq8074,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_ipq8074,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_ipq8074,
|
||||
|
@ -1564,9 +1594,7 @@ const struct ath11k_hw_ops ipq6018_ops = {
|
|||
};
|
||||
|
||||
const struct ath11k_hw_ops qca6390_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq8074_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq8074_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_qca6390,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_qca6390,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_qca6390,
|
||||
|
@ -1618,13 +1646,11 @@ const struct ath11k_hw_ops qca6390_ops = {
|
|||
};
|
||||
|
||||
const struct ath11k_hw_ops qcn9074_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq6018_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq6018_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_ipq8074,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_ipq8074,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_ipq8074,
|
||||
#ifdef notyet
|
||||
#if notyet
|
||||
.tx_mesh_enable = ath11k_hw_qcn9074_tx_mesh_enable,
|
||||
.rx_desc_get_first_msdu = ath11k_hw_qcn9074_rx_desc_get_first_msdu,
|
||||
.rx_desc_get_last_msdu = ath11k_hw_qcn9074_rx_desc_get_last_msdu,
|
||||
|
@ -1672,13 +1698,11 @@ const struct ath11k_hw_ops qcn9074_ops = {
|
|||
};
|
||||
|
||||
const struct ath11k_hw_ops wcn6855_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq8074_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq8074_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_qca6390,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_qca6390,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_qca6390,
|
||||
#ifdef notyet
|
||||
#if notyet
|
||||
.tx_mesh_enable = ath11k_hw_wcn6855_tx_mesh_enable,
|
||||
.rx_desc_get_first_msdu = ath11k_hw_wcn6855_rx_desc_get_first_msdu,
|
||||
.rx_desc_get_last_msdu = ath11k_hw_wcn6855_rx_desc_get_last_msdu,
|
||||
|
@ -1726,9 +1750,7 @@ const struct ath11k_hw_ops wcn6855_ops = {
|
|||
};
|
||||
|
||||
const struct ath11k_hw_ops wcn6750_ops = {
|
||||
#if notyet
|
||||
.get_hw_mac_from_pdev_id = ath11k_hw_ipq8074_mac_from_pdev_id,
|
||||
#endif
|
||||
.get_hw_mac_from_pdev_id = qwx_hw_ipq8074_mac_from_pdev_id,
|
||||
.wmi_init_config = qwx_init_wmi_config_qca6390,
|
||||
.mac_id_to_pdev_id = qwx_hw_mac_id_to_pdev_id_qca6390,
|
||||
.mac_id_to_srng_id = qwx_hw_mac_id_to_srng_id_qca6390,
|
||||
|
@ -3052,7 +3074,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
.sram_dump = {},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3139,7 +3163,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
.sram_dump = {},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3228,7 +3254,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3316,7 +3344,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
.sram_dump = {},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3405,7 +3435,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3493,7 +3525,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
},
|
||||
|
||||
.tcl_ring_retry = true,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = false,
|
||||
#endif
|
||||
},
|
||||
|
@ -3578,7 +3612,9 @@ static const struct ath11k_hw_params ath11k_hw_params[] = {
|
|||
.sram_dump = {},
|
||||
|
||||
.tcl_ring_retry = false,
|
||||
#endif
|
||||
.tx_ring_size = DP_TCL_DATA_RING_SIZE_WCN6750,
|
||||
#ifdef notyet
|
||||
.smp2p_wow_exit = true,
|
||||
#endif
|
||||
},
|
||||
|
@ -7815,7 +7851,15 @@ qwx_core_check_smbios(struct qwx_softc *sc)
|
|||
int
|
||||
qwx_core_check_dt(struct qwx_softc *sc)
|
||||
{
|
||||
return 0; /* TODO */
|
||||
#ifdef __HAVE_FDT
|
||||
if (sc->sc_node == 0)
|
||||
return 0;
|
||||
|
||||
OF_getprop(sc->sc_node, "qcom,ath11k-calibration-variant",
|
||||
sc->qmi_target.bdf_ext, sizeof(sc->qmi_target.bdf_ext) - 1);
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
|
@ -9953,6 +9997,51 @@ qwx_dp_link_desc_cleanup(struct qwx_softc *sc,
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
qwx_dp_tx_ring_free_tx_data(struct qwx_softc *sc, struct dp_tx_ring *tx_ring)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (tx_ring->data == NULL)
|
||||
return;
|
||||
|
||||
for (i = 0; i < sc->hw_params.tx_ring_size; i++) {
|
||||
struct qwx_tx_data *tx_data = &tx_ring->data[i];
|
||||
|
||||
if (tx_data->map) {
|
||||
bus_dmamap_unload(sc->sc_dmat, tx_data->map);
|
||||
bus_dmamap_destroy(sc->sc_dmat, tx_data->map);
|
||||
}
|
||||
|
||||
m_freem(tx_data->m);
|
||||
}
|
||||
|
||||
free(tx_ring->data, M_DEVBUF,
|
||||
sc->hw_params.tx_ring_size * sizeof(struct qwx_tx_data));
|
||||
tx_ring->data = NULL;
|
||||
}
|
||||
|
||||
int
|
||||
qwx_dp_tx_ring_alloc_tx_data(struct qwx_softc *sc, struct dp_tx_ring *tx_ring)
|
||||
{
|
||||
int i, ret;
|
||||
|
||||
tx_ring->data = mallocarray(sc->hw_params.tx_ring_size,
|
||||
sizeof(struct qwx_tx_data), M_DEVBUF, M_NOWAIT | M_ZERO);
|
||||
if (tx_ring->data == NULL)
|
||||
return ENOMEM;
|
||||
|
||||
for (i = 0; i < sc->hw_params.tx_ring_size; i++) {
|
||||
struct qwx_tx_data *tx_data = &tx_ring->data[i];
|
||||
|
||||
ret = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES, 0,
|
||||
BUS_DMA_NOWAIT, &tx_data->map);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
qwx_dp_alloc(struct qwx_softc *sc)
|
||||
|
@ -10003,8 +10092,13 @@ qwx_dp_alloc(struct qwx_softc *sc)
|
|||
idr_init(&dp->tx_ring[i].txbuf_idr);
|
||||
spin_lock_init(&dp->tx_ring[i].tx_idr_lock);
|
||||
#endif
|
||||
dp->tx_ring[i].tcl_data_ring_id = i;
|
||||
ret = qwx_dp_tx_ring_alloc_tx_data(sc, &dp->tx_ring[i]);
|
||||
if (ret)
|
||||
goto fail_cmn_srng_cleanup;
|
||||
|
||||
dp->tx_ring[i].cur = 0;
|
||||
dp->tx_ring[i].queued = 0;
|
||||
dp->tx_ring[i].tcl_data_ring_id = i;
|
||||
dp->tx_ring[i].tx_status_head = 0;
|
||||
dp->tx_ring[i].tx_status_tail = DP_TX_COMP_RING_SIZE - 1;
|
||||
dp->tx_ring[i].tx_status = malloc(size, M_DEVBUF,
|
||||
|
@ -10051,6 +10145,7 @@ qwx_dp_free(struct qwx_softc *sc)
|
|||
idr_destroy(&dp->tx_ring[i].txbuf_idr);
|
||||
spin_unlock_bh(&dp->tx_ring[i].tx_idr_lock);
|
||||
#endif
|
||||
qwx_dp_tx_ring_free_tx_data(sc, &dp->tx_ring[i]);
|
||||
free(dp->tx_ring[i].tx_status, M_DEVBUF,
|
||||
sizeof(struct hal_wbm_release_ring) * DP_TX_COMP_RING_SIZE);
|
||||
dp->tx_ring[i].tx_status = NULL;
|
||||
|
@ -14544,9 +14639,146 @@ qwx_dp_vdev_tx_attach(struct qwx_softc *sc, struct qwx_pdev *pdev,
|
|||
qwx_dp_update_vdev_search(sc, arvif);
|
||||
}
|
||||
|
||||
void
|
||||
qwx_dp_tx_status_parse(struct qwx_softc *sc, struct hal_wbm_release_ring *desc,
|
||||
struct hal_tx_status *ts)
|
||||
{
|
||||
ts->buf_rel_source = FIELD_GET(HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE,
|
||||
desc->info0);
|
||||
if (ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_FW &&
|
||||
ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_TQM)
|
||||
return;
|
||||
|
||||
if (ts->buf_rel_source == HAL_WBM_REL_SRC_MODULE_FW)
|
||||
return;
|
||||
|
||||
ts->status = FIELD_GET(HAL_WBM_RELEASE_INFO0_TQM_RELEASE_REASON,
|
||||
desc->info0);
|
||||
ts->ppdu_id = FIELD_GET(HAL_WBM_RELEASE_INFO1_TQM_STATUS_NUMBER,
|
||||
desc->info1);
|
||||
ts->try_cnt = FIELD_GET(HAL_WBM_RELEASE_INFO1_TRANSMIT_COUNT,
|
||||
desc->info1);
|
||||
ts->ack_rssi = FIELD_GET(HAL_WBM_RELEASE_INFO2_ACK_FRAME_RSSI,
|
||||
desc->info2);
|
||||
if (desc->info2 & HAL_WBM_RELEASE_INFO2_FIRST_MSDU)
|
||||
ts->flags |= HAL_TX_STATUS_FLAGS_FIRST_MSDU;
|
||||
ts->peer_id = FIELD_GET(HAL_WBM_RELEASE_INFO3_PEER_ID, desc->info3);
|
||||
ts->tid = FIELD_GET(HAL_WBM_RELEASE_INFO3_TID, desc->info3);
|
||||
if (desc->rate_stats.info0 & HAL_TX_RATE_STATS_INFO0_VALID)
|
||||
ts->rate_stats = desc->rate_stats.info0;
|
||||
else
|
||||
ts->rate_stats = 0;
|
||||
}
|
||||
|
||||
void
|
||||
qwx_dp_tx_process_htt_tx_complete(struct qwx_softc *sc, void *desc,
|
||||
uint8_t mac_id, uint32_t msdu_id, struct dp_tx_ring *tx_ring)
|
||||
{
|
||||
printf("%s: not implemented\n", __func__);
|
||||
}
|
||||
|
||||
void
|
||||
qwx_dp_tx_complete_msdu(struct qwx_softc *sc, struct dp_tx_ring *tx_ring,
|
||||
uint32_t msdu_id, struct hal_tx_status *ts)
|
||||
{
|
||||
struct qwx_tx_data *tx_data = &tx_ring->data[msdu_id];
|
||||
|
||||
if (ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_TQM) {
|
||||
/* Must not happen */
|
||||
return;
|
||||
}
|
||||
|
||||
bus_dmamap_unload(sc->sc_dmat, tx_data->map);
|
||||
m_freem(tx_data->m);
|
||||
tx_data->m = NULL;
|
||||
|
||||
/* TODO: Tx rate adjustment? */
|
||||
|
||||
if (tx_ring->queued > 0)
|
||||
tx_ring->queued--;
|
||||
}
|
||||
|
||||
#define QWX_TX_COMPL_NEXT(x) (((x) + 1) % DP_TX_COMP_RING_SIZE)
|
||||
|
||||
int
|
||||
qwx_dp_tx_completion_handler(struct qwx_softc *sc, int ring_id)
|
||||
{
|
||||
struct qwx_dp *dp = &sc->dp;
|
||||
int hal_ring_id = dp->tx_ring[ring_id].tcl_comp_ring.ring_id;
|
||||
struct hal_srng *status_ring = &sc->hal.srng_list[hal_ring_id];
|
||||
struct hal_tx_status ts = { 0 };
|
||||
struct dp_tx_ring *tx_ring = &dp->tx_ring[ring_id];
|
||||
uint32_t *desc;
|
||||
uint32_t msdu_id;
|
||||
uint8_t mac_id;
|
||||
#ifdef notyet
|
||||
spin_lock_bh(&status_ring->lock);
|
||||
#endif
|
||||
qwx_hal_srng_access_begin(sc, status_ring);
|
||||
|
||||
while ((QWX_TX_COMPL_NEXT(tx_ring->tx_status_head) !=
|
||||
tx_ring->tx_status_tail) &&
|
||||
(desc = qwx_hal_srng_dst_get_next_entry(sc, status_ring))) {
|
||||
memcpy(&tx_ring->tx_status[tx_ring->tx_status_head], desc,
|
||||
sizeof(struct hal_wbm_release_ring));
|
||||
tx_ring->tx_status_head =
|
||||
QWX_TX_COMPL_NEXT(tx_ring->tx_status_head);
|
||||
}
|
||||
#if 0
|
||||
if (unlikely((ath11k_hal_srng_dst_peek(ab, status_ring) != NULL) &&
|
||||
(ATH11K_TX_COMPL_NEXT(tx_ring->tx_status_head) ==
|
||||
tx_ring->tx_status_tail))) {
|
||||
/* TODO: Process pending tx_status messages when kfifo_is_full() */
|
||||
ath11k_warn(ab, "Unable to process some of the tx_status ring desc because status_fifo is full\n");
|
||||
}
|
||||
#endif
|
||||
qwx_hal_srng_access_end(sc, status_ring);
|
||||
#ifdef notyet
|
||||
spin_unlock_bh(&status_ring->lock);
|
||||
#endif
|
||||
while (QWX_TX_COMPL_NEXT(tx_ring->tx_status_tail) !=
|
||||
tx_ring->tx_status_head) {
|
||||
struct hal_wbm_release_ring *tx_status;
|
||||
uint32_t desc_id;
|
||||
|
||||
tx_ring->tx_status_tail =
|
||||
QWX_TX_COMPL_NEXT(tx_ring->tx_status_tail);
|
||||
tx_status = &tx_ring->tx_status[tx_ring->tx_status_tail];
|
||||
qwx_dp_tx_status_parse(sc, tx_status, &ts);
|
||||
|
||||
desc_id = FIELD_GET(BUFFER_ADDR_INFO1_SW_COOKIE,
|
||||
tx_status->buf_addr_info.info1);
|
||||
mac_id = FIELD_GET(DP_TX_DESC_ID_MAC_ID, desc_id);
|
||||
if (mac_id >= MAX_RADIOS)
|
||||
continue;
|
||||
msdu_id = FIELD_GET(DP_TX_DESC_ID_MSDU_ID, desc_id);
|
||||
if (msdu_id >= sc->hw_params.tx_ring_size)
|
||||
continue;
|
||||
|
||||
if (ts.buf_rel_source == HAL_WBM_REL_SRC_MODULE_FW) {
|
||||
qwx_dp_tx_process_htt_tx_complete(sc,
|
||||
(void *)tx_status, mac_id, msdu_id, tx_ring);
|
||||
continue;
|
||||
}
|
||||
#if 0
|
||||
spin_lock(&tx_ring->tx_idr_lock);
|
||||
msdu = idr_remove(&tx_ring->txbuf_idr, msdu_id);
|
||||
if (unlikely(!msdu)) {
|
||||
ath11k_warn(ab, "tx completion for unknown msdu_id %d\n",
|
||||
msdu_id);
|
||||
spin_unlock(&tx_ring->tx_idr_lock);
|
||||
continue;
|
||||
}
|
||||
|
||||
spin_unlock(&tx_ring->tx_idr_lock);
|
||||
ar = ab->pdevs[mac_id].ar;
|
||||
|
||||
if (atomic_dec_and_test(&ar->dp.num_tx_pending))
|
||||
wake_up(&ar->dp.tx_empty_waitq);
|
||||
#endif
|
||||
qwx_dp_tx_complete_msdu(sc, tx_ring, msdu_id, &ts);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -21050,6 +21282,7 @@ int
|
|||
qwx_peer_create(struct qwx_softc *sc, struct qwx_vif *arvif, uint8_t pdev_id,
|
||||
struct ieee80211_node *ni, struct peer_create_params *param)
|
||||
{
|
||||
struct ieee80211com *ic = &sc->sc_ic;
|
||||
struct qwx_node *nq = (struct qwx_node *)ni;
|
||||
struct ath11k_peer *peer;
|
||||
int ret;
|
||||
|
@ -21131,11 +21364,12 @@ qwx_peer_create(struct qwx_softc *sc, struct qwx_vif *arvif, uint8_t pdev_id,
|
|||
peer->pdev_id = pdev_id;
|
||||
#if 0
|
||||
peer->sta = sta;
|
||||
|
||||
if (arvif->vif->type == NL80211_IFTYPE_STATION) {
|
||||
#endif
|
||||
if (ic->ic_opmode == IEEE80211_M_STA) {
|
||||
arvif->ast_hash = peer->ast_hash;
|
||||
arvif->ast_idx = peer->hw_peer_id;
|
||||
}
|
||||
#if 0
|
||||
peer->sec_type = HAL_ENCRYPT_TYPE_OPEN;
|
||||
peer->sec_type_grp = HAL_ENCRYPT_TYPE_OPEN;
|
||||
|
||||
|
@ -21715,6 +21949,249 @@ peer_clean:
|
|||
return ret;
|
||||
}
|
||||
|
||||
enum hal_tcl_encap_type
|
||||
qwx_dp_tx_get_encap_type(struct qwx_softc *sc)
|
||||
{
|
||||
if (test_bit(ATH11K_FLAG_RAW_MODE, sc->sc_flags))
|
||||
return HAL_TCL_ENCAP_TYPE_RAW;
|
||||
#if 0
|
||||
if (tx_info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP)
|
||||
return HAL_TCL_ENCAP_TYPE_ETHERNET;
|
||||
#endif
|
||||
return HAL_TCL_ENCAP_TYPE_NATIVE_WIFI;
|
||||
}
|
||||
|
||||
uint8_t
|
||||
qwx_dp_tx_get_tid(struct mbuf *m)
|
||||
{
|
||||
struct ieee80211_frame *wh = mtod(m, struct ieee80211_frame *);
|
||||
uint16_t qos = ieee80211_get_qos(wh);
|
||||
uint8_t tid = qos & IEEE80211_QOS_TID;
|
||||
|
||||
return tid;
|
||||
}
|
||||
|
||||
void
|
||||
qwx_hal_tx_cmd_desc_setup(struct qwx_softc *sc, void *cmd,
|
||||
struct hal_tx_info *ti)
|
||||
{
|
||||
struct hal_tcl_data_cmd *tcl_cmd = (struct hal_tcl_data_cmd *)cmd;
|
||||
|
||||
tcl_cmd->buf_addr_info.info0 = FIELD_PREP(BUFFER_ADDR_INFO0_ADDR,
|
||||
ti->paddr);
|
||||
tcl_cmd->buf_addr_info.info1 = FIELD_PREP(BUFFER_ADDR_INFO1_ADDR,
|
||||
((uint64_t)ti->paddr >> HAL_ADDR_MSB_REG_SHIFT));
|
||||
tcl_cmd->buf_addr_info.info1 |= FIELD_PREP(
|
||||
BUFFER_ADDR_INFO1_RET_BUF_MGR, ti->rbm_id) |
|
||||
FIELD_PREP(BUFFER_ADDR_INFO1_SW_COOKIE, ti->desc_id);
|
||||
|
||||
tcl_cmd->info0 =
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_DESC_TYPE, ti->type) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_ENCAP_TYPE, ti->encap_type) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_ENCRYPT_TYPE, ti->encrypt_type) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_SEARCH_TYPE, ti->search_type) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_ADDR_EN, ti->addr_search_flags) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO0_CMD_NUM, ti->meta_data_flags);
|
||||
|
||||
tcl_cmd->info1 = ti->flags0 |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_DATA_LEN, ti->data_len) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_PKT_OFFSET, ti->pkt_offset);
|
||||
|
||||
tcl_cmd->info2 = ti->flags1 |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_TID, ti->tid) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_LMAC_ID, ti->lmac_id);
|
||||
|
||||
tcl_cmd->info3 = FIELD_PREP(HAL_TCL_DATA_CMD_INFO3_DSCP_TID_TABLE_IDX,
|
||||
ti->dscp_tid_tbl_idx) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO3_SEARCH_INDEX, ti->bss_ast_idx) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO3_CACHE_SET_NUM, ti->bss_ast_hash);
|
||||
tcl_cmd->info4 = 0;
|
||||
#ifdef notyet
|
||||
if (ti->enable_mesh)
|
||||
ab->hw_params.hw_ops->tx_mesh_enable(ab, tcl_cmd);
|
||||
#endif
|
||||
}
|
||||
|
||||
int
|
||||
qwx_dp_tx(struct qwx_softc *sc, struct qwx_vif *arvif, uint8_t pdev_id,
|
||||
struct ieee80211_node *ni, struct mbuf *m)
|
||||
{
|
||||
struct ieee80211com *ic = &sc->sc_ic;
|
||||
struct qwx_dp *dp = &sc->dp;
|
||||
struct hal_tx_info ti = {0};
|
||||
struct qwx_tx_data *tx_data;
|
||||
struct hal_srng *tcl_ring;
|
||||
struct ieee80211_frame *wh = mtod(m, struct ieee80211_frame *);
|
||||
struct ieee80211_key *k = NULL;
|
||||
struct dp_tx_ring *tx_ring;
|
||||
void *hal_tcl_desc;
|
||||
uint8_t pool_id;
|
||||
uint8_t hal_ring_id;
|
||||
int ret, msdu_id;
|
||||
uint32_t ring_selector = 0;
|
||||
uint8_t ring_map = 0;
|
||||
|
||||
if (test_bit(ATH11K_FLAG_CRASH_FLUSH, sc->sc_flags)) {
|
||||
m_freem(m);
|
||||
printf("%s: crash flush\n", __func__);
|
||||
return ESHUTDOWN;
|
||||
}
|
||||
#if 0
|
||||
if (unlikely(!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP) &&
|
||||
!ieee80211_is_data(hdr->frame_control)))
|
||||
return -ENOTSUPP;
|
||||
#endif
|
||||
pool_id = 0;
|
||||
ring_selector = 0;
|
||||
|
||||
ti.ring_id = ring_selector % sc->hw_params.max_tx_ring;
|
||||
ti.rbm_id = sc->hw_params.hal_params->tcl2wbm_rbm_map[ti.ring_id].rbm_id;
|
||||
|
||||
ring_map |= (1 << ti.ring_id);
|
||||
|
||||
tx_ring = &dp->tx_ring[ti.ring_id];
|
||||
|
||||
if (tx_ring->queued >= sc->hw_params.tx_ring_size) {
|
||||
m_freem(m);
|
||||
return ENOSPC;
|
||||
}
|
||||
|
||||
msdu_id = tx_ring->cur;
|
||||
tx_data = &tx_ring->data[msdu_id];
|
||||
if (tx_data->m != NULL) {
|
||||
m_freem(m);
|
||||
return ENOSPC;
|
||||
}
|
||||
|
||||
ti.desc_id = FIELD_PREP(DP_TX_DESC_ID_MAC_ID, pdev_id) |
|
||||
FIELD_PREP(DP_TX_DESC_ID_MSDU_ID, msdu_id) |
|
||||
FIELD_PREP(DP_TX_DESC_ID_POOL_ID, pool_id);
|
||||
ti.encap_type = qwx_dp_tx_get_encap_type(sc);
|
||||
|
||||
ti.meta_data_flags = arvif->tcl_metadata;
|
||||
|
||||
if (ti.encap_type == HAL_TCL_ENCAP_TYPE_RAW) {
|
||||
#if 0
|
||||
if (skb_cb->flags & ATH11K_SKB_CIPHER_SET) {
|
||||
ti.encrypt_type =
|
||||
ath11k_dp_tx_get_encrypt_type(skb_cb->cipher);
|
||||
|
||||
if (ieee80211_has_protected(hdr->frame_control))
|
||||
skb_put(skb, IEEE80211_CCMP_MIC_LEN);
|
||||
} else
|
||||
#endif
|
||||
ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN;
|
||||
|
||||
if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
|
||||
k = ieee80211_get_txkey(ic, wh, ni);
|
||||
if ((m = ieee80211_encrypt(ic, m, k)) == NULL) {
|
||||
printf("%s: encrypt failed\n", __func__);
|
||||
return ENOBUFS;
|
||||
}
|
||||
/* 802.11 header may have moved. */
|
||||
wh = mtod(m, struct ieee80211_frame *);
|
||||
}
|
||||
}
|
||||
|
||||
ti.addr_search_flags = arvif->hal_addr_search_flags;
|
||||
ti.search_type = arvif->search_type;
|
||||
ti.type = HAL_TCL_DESC_TYPE_BUFFER;
|
||||
ti.pkt_offset = 0;
|
||||
ti.lmac_id = qwx_hw_get_mac_from_pdev_id(sc, pdev_id);
|
||||
ti.bss_ast_hash = arvif->ast_hash;
|
||||
ti.bss_ast_idx = arvif->ast_idx;
|
||||
ti.dscp_tid_tbl_idx = 0;
|
||||
#if 0
|
||||
if (likely(skb->ip_summed == CHECKSUM_PARTIAL &&
|
||||
ti.encap_type != HAL_TCL_ENCAP_TYPE_RAW)) {
|
||||
ti.flags0 |= FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_IP4_CKSUM_EN, 1) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_UDP4_CKSUM_EN, 1) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_UDP6_CKSUM_EN, 1) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_TCP4_CKSUM_EN, 1) |
|
||||
FIELD_PREP(HAL_TCL_DATA_CMD_INFO1_TCP6_CKSUM_EN, 1);
|
||||
}
|
||||
|
||||
if (ieee80211_vif_is_mesh(arvif->vif))
|
||||
ti.enable_mesh = true;
|
||||
#endif
|
||||
ti.flags1 |= FIELD_PREP(HAL_TCL_DATA_CMD_INFO2_TID_OVERWRITE, 1);
|
||||
|
||||
ti.tid = qwx_dp_tx_get_tid(m);
|
||||
#if 0
|
||||
switch (ti.encap_type) {
|
||||
case HAL_TCL_ENCAP_TYPE_NATIVE_WIFI:
|
||||
ath11k_dp_tx_encap_nwifi(skb);
|
||||
break;
|
||||
case HAL_TCL_ENCAP_TYPE_RAW:
|
||||
if (!test_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags)) {
|
||||
ret = -EINVAL;
|
||||
goto fail_remove_idr;
|
||||
}
|
||||
break;
|
||||
case HAL_TCL_ENCAP_TYPE_ETHERNET:
|
||||
/* no need to encap */
|
||||
break;
|
||||
case HAL_TCL_ENCAP_TYPE_802_3:
|
||||
default:
|
||||
/* TODO: Take care of other encap modes as well */
|
||||
ret = -EINVAL;
|
||||
atomic_inc(&ab->soc_stats.tx_err.misc_fail);
|
||||
goto fail_remove_idr;
|
||||
}
|
||||
#endif
|
||||
ret = bus_dmamap_load_mbuf(sc->sc_dmat, tx_data->map,
|
||||
m, BUS_DMA_WRITE | BUS_DMA_NOWAIT);
|
||||
if (ret) {
|
||||
printf("%s: failed to map Tx buffer: %d\n",
|
||||
sc->sc_dev.dv_xname, ret);
|
||||
m_freem(m);
|
||||
return ret;
|
||||
}
|
||||
ti.paddr = tx_data->map->dm_segs[0].ds_addr;
|
||||
|
||||
ti.data_len = m->m_pkthdr.len;
|
||||
|
||||
hal_ring_id = tx_ring->tcl_data_ring.ring_id;
|
||||
tcl_ring = &sc->hal.srng_list[hal_ring_id];
|
||||
#ifdef notyet
|
||||
spin_lock_bh(&tcl_ring->lock);
|
||||
#endif
|
||||
qwx_hal_srng_access_begin(sc, tcl_ring);
|
||||
|
||||
hal_tcl_desc = (void *)qwx_hal_srng_src_get_next_entry(sc, tcl_ring);
|
||||
if (!hal_tcl_desc) {
|
||||
printf("%s: hal_tcl_desc == NULL\n", __func__);
|
||||
/* NOTE: It is highly unlikely we'll be running out of tcl_ring
|
||||
* desc because the desc is directly enqueued onto hw queue.
|
||||
*/
|
||||
qwx_hal_srng_access_end(sc, tcl_ring);
|
||||
#if 0
|
||||
ab->soc_stats.tx_err.desc_na[ti.ring_id]++;
|
||||
#endif
|
||||
#ifdef notyet
|
||||
spin_unlock_bh(&tcl_ring->lock);
|
||||
#endif
|
||||
bus_dmamap_unload(sc->sc_dmat, tx_data->map);
|
||||
m_freem(m);
|
||||
return ENOMEM;
|
||||
}
|
||||
|
||||
tx_data->m = m;
|
||||
|
||||
qwx_hal_tx_cmd_desc_setup(sc,
|
||||
hal_tcl_desc + sizeof(struct hal_tlv_hdr), &ti);
|
||||
|
||||
qwx_hal_srng_access_end(sc, tcl_ring);
|
||||
|
||||
qwx_dp_shadow_start_timer(sc, tcl_ring, &dp->tx_ring_timer[ti.ring_id]);
|
||||
#ifdef notyet
|
||||
spin_unlock_bh(&tcl_ring->lock);
|
||||
#endif
|
||||
tx_ring->queued++;
|
||||
tx_ring->cur = (tx_ring->cur + 1) % sc->hw_params.tx_ring_size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
qwx_mac_station_add(struct qwx_softc *sc, struct qwx_vif *arvif,
|
||||
uint8_t pdev_id, struct ieee80211_node *ni)
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: qwxreg.h,v 1.5 2024/02/02 15:44:19 stsp Exp $ */
|
||||
/* $OpenBSD: qwxreg.h,v 1.6 2024/02/03 10:03:18 stsp Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc.
|
||||
|
@ -38,6 +38,16 @@
|
|||
* core.h
|
||||
*/
|
||||
|
||||
#define ATH11K_TX_MGMT_NUM_PENDING_MAX 512
|
||||
|
||||
#define ATH11K_TX_MGMT_TARGET_MAX_SUPPORT_WMI 64
|
||||
|
||||
/* Pending management packets threshold for dropping probe responses */
|
||||
#define ATH11K_PRB_RSP_DROP_THRESHOLD ((ATH11K_TX_MGMT_TARGET_MAX_SUPPORT_WMI * 3) / 4)
|
||||
|
||||
#define ATH11K_INVALID_HW_MAC_ID 0xFF
|
||||
#define ATH11K_CONNECTION_LOSS_HZ (3 * HZ)
|
||||
|
||||
enum ath11k_hw_rev {
|
||||
ATH11K_HW_IPQ8074,
|
||||
ATH11K_HW_QCA6390_HW20,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: qwxvar.h,v 1.9 2024/02/02 15:44:19 stsp Exp $ */
|
||||
/* $OpenBSD: qwxvar.h,v 1.11 2024/02/03 20:07:19 kettenis Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2018-2019 The Linux Foundation.
|
||||
|
@ -113,6 +113,53 @@ struct ath11k_hw_hal_params {
|
|||
const struct ath11k_hw_tcl2wbm_rbm_map *tcl2wbm_rbm_map;
|
||||
};
|
||||
|
||||
struct hal_tx_info {
|
||||
uint16_t meta_data_flags; /* %HAL_TCL_DATA_CMD_INFO0_META_ */
|
||||
uint8_t ring_id;
|
||||
uint32_t desc_id;
|
||||
enum hal_tcl_desc_type type;
|
||||
enum hal_tcl_encap_type encap_type;
|
||||
uint64_t paddr;
|
||||
uint32_t data_len;
|
||||
uint32_t pkt_offset;
|
||||
enum hal_encrypt_type encrypt_type;
|
||||
uint32_t flags0; /* %HAL_TCL_DATA_CMD_INFO1_ */
|
||||
uint32_t flags1; /* %HAL_TCL_DATA_CMD_INFO2_ */
|
||||
uint16_t addr_search_flags; /* %HAL_TCL_DATA_CMD_INFO0_ADDR(X/Y)_ */
|
||||
uint16_t bss_ast_hash;
|
||||
uint16_t bss_ast_idx;
|
||||
uint8_t tid;
|
||||
uint8_t search_type; /* %HAL_TX_ADDR_SEARCH_ */
|
||||
uint8_t lmac_id;
|
||||
uint8_t dscp_tid_tbl_idx;
|
||||
bool enable_mesh;
|
||||
uint8_t rbm_id;
|
||||
};
|
||||
|
||||
/* TODO: Check if the actual desc macros can be used instead */
|
||||
#define HAL_TX_STATUS_FLAGS_FIRST_MSDU BIT(0)
|
||||
#define HAL_TX_STATUS_FLAGS_LAST_MSDU BIT(1)
|
||||
#define HAL_TX_STATUS_FLAGS_MSDU_IN_AMSDU BIT(2)
|
||||
#define HAL_TX_STATUS_FLAGS_RATE_STATS_VALID BIT(3)
|
||||
#define HAL_TX_STATUS_FLAGS_RATE_LDPC BIT(4)
|
||||
#define HAL_TX_STATUS_FLAGS_RATE_STBC BIT(5)
|
||||
#define HAL_TX_STATUS_FLAGS_OFDMA BIT(6)
|
||||
|
||||
#define HAL_TX_STATUS_DESC_LEN sizeof(struct hal_wbm_release_ring)
|
||||
|
||||
/* Tx status parsed from srng desc */
|
||||
struct hal_tx_status {
|
||||
enum hal_wbm_rel_src_module buf_rel_source;
|
||||
enum hal_wbm_tqm_rel_reason status;
|
||||
uint8_t ack_rssi;
|
||||
uint32_t flags; /* %HAL_TX_STATUS_FLAGS_ */
|
||||
uint32_t ppdu_id;
|
||||
uint8_t try_cnt;
|
||||
uint8_t tid;
|
||||
uint16_t peer_id;
|
||||
uint32_t rate_stats;
|
||||
};
|
||||
|
||||
struct ath11k_hw_params {
|
||||
const char *name;
|
||||
uint16_t hw_rev;
|
||||
|
@ -209,9 +256,7 @@ struct ath11k_hw_params {
|
|||
};
|
||||
|
||||
struct ath11k_hw_ops {
|
||||
#if notyet
|
||||
uint8_t (*get_hw_mac_from_pdev_id)(int pdev_id);
|
||||
#endif
|
||||
void (*wmi_init_config)(struct qwx_softc *sc,
|
||||
struct target_resource_config *config);
|
||||
int (*mac_id_to_pdev_id)(struct ath11k_hw_params *hw, int mac_id);
|
||||
|
@ -922,11 +967,9 @@ struct dp_tx_ring {
|
|||
uint8_t tcl_data_ring_id;
|
||||
struct dp_srng tcl_data_ring;
|
||||
struct dp_srng tcl_comp_ring;
|
||||
#if 0
|
||||
struct idr txbuf_idr;
|
||||
/* Protects txbuf_idr and num_pending */
|
||||
spinlock_t tx_idr_lock;
|
||||
#endif
|
||||
int cur;
|
||||
int queued;
|
||||
struct qwx_tx_data *data;
|
||||
struct hal_wbm_release_ring *tx_status;
|
||||
int tx_status_head;
|
||||
int tx_status_tail;
|
||||
|
@ -1585,6 +1628,7 @@ struct qwx_softc {
|
|||
struct device sc_dev;
|
||||
struct ieee80211com sc_ic;
|
||||
uint32_t sc_flags;
|
||||
int sc_node;
|
||||
|
||||
int (*sc_newstate)(struct ieee80211com *, enum ieee80211_state, int);
|
||||
|
||||
|
|
|
@ -2120,8 +2120,10 @@ static struct edid *edid_filter_invalid_blocks(struct edid *edid,
|
|||
kfree(edid);
|
||||
#else
|
||||
new = kmalloc(*alloc_size, GFP_KERNEL);
|
||||
if (!new)
|
||||
if (!new) {
|
||||
kfree(edid);
|
||||
return NULL;
|
||||
}
|
||||
memcpy(new, edid, EDID_LENGTH);
|
||||
kfree(edid);
|
||||
#endif
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: if_qwx_pci.c,v 1.4 2024/01/25 17:00:21 stsp Exp $ */
|
||||
/* $OpenBSD: if_qwx_pci.c,v 1.5 2024/02/03 20:07:19 kettenis Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright 2023 Stefan Sperling <stsp@openbsd.org>
|
||||
|
@ -770,6 +770,10 @@ qwx_pci_attach(struct device *parent, struct device *self, void *aux)
|
|||
psc->sc_pc = pa->pa_pc;
|
||||
psc->sc_tag = pa->pa_tag;
|
||||
|
||||
#ifdef __HAVE_FDT
|
||||
sc->sc_node = PCITAG_NODE(pa->pa_tag);
|
||||
#endif
|
||||
|
||||
rw_init(&sc->ioctl_rwl, "qwxioctl");
|
||||
|
||||
sreg = pci_conf_read(psc->sc_pc, psc->sc_tag, PCI_SUBSYS_ID_REG);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: pcivar.h,v 1.78 2023/04/13 15:07:43 miod Exp $ */
|
||||
/* $OpenBSD: pcivar.h,v 1.79 2024/02/03 10:37:26 kettenis Exp $ */
|
||||
/* $NetBSD: pcivar.h,v 1.23 1997/06/06 23:48:05 thorpej Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -161,13 +161,15 @@ struct pci_attach_args {
|
|||
*
|
||||
* OpenBSD doesn't actually use them yet -- csapuntz@cvs.openbsd.org
|
||||
*/
|
||||
#define PCI_FLAGS_IO_ENABLED 0x01 /* I/O space is enabled */
|
||||
#define PCI_FLAGS_MEM_ENABLED 0x02 /* memory space is enabled */
|
||||
#define PCI_FLAGS_MRL_OKAY 0x04 /* Memory Read Line okay */
|
||||
#define PCI_FLAGS_MRM_OKAY 0x08 /* Memory Read Multiple okay */
|
||||
#define PCI_FLAGS_MWI_OKAY 0x10 /* Memory Write and Invalidate
|
||||
#define PCI_FLAGS_IO_ENABLED 0x01 /* I/O space is enabled */
|
||||
#define PCI_FLAGS_MEM_ENABLED 0x02 /* memory space is enabled */
|
||||
#define PCI_FLAGS_MRL_OKAY 0x04 /* Memory Read Line okay */
|
||||
#define PCI_FLAGS_MRM_OKAY 0x08 /* Memory Read Multiple okay */
|
||||
#define PCI_FLAGS_MWI_OKAY 0x10 /* Memory Write and Invalidate
|
||||
okay */
|
||||
#define PCI_FLAGS_MSI_ENABLED 0x20 /* Message Signaled Interrupt
|
||||
#define PCI_FLAGS_MSI_ENABLED 0x20 /* Message Signaled Interrupt
|
||||
enabled */
|
||||
#define PCI_FLAGS_MSIVEC_ENABLED 0x40 /* Multiple Message Capability
|
||||
enabled */
|
||||
|
||||
/*
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: softraid.c,v 1.429 2022/12/21 09:54:23 kn Exp $ */
|
||||
/* $OpenBSD: softraid.c,v 1.430 2024/02/03 18:51:58 beck Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2007, 2008, 2009 Marco Peereboom <marco@peereboom.us>
|
||||
* Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org>
|
||||
|
@ -445,7 +445,6 @@ sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr_t blkno,
|
|||
splx(s);
|
||||
}
|
||||
|
||||
LIST_INIT(&b.b_dep);
|
||||
VOP_STRATEGY(vp, &b);
|
||||
biowait(&b);
|
||||
|
||||
|
@ -2018,8 +2017,6 @@ sr_ccb_rw(struct sr_discipline *sd, int chunk, daddr_t blkno,
|
|||
splx(s);
|
||||
}
|
||||
|
||||
LIST_INIT(&ccb->ccb_buf.b_dep);
|
||||
|
||||
DNPRINTF(SR_D_DIS, "%s: %s %s ccb "
|
||||
"b_bcount %ld b_blkno %lld b_flags 0x%0lx b_data %p\n",
|
||||
DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_physio.c,v 1.48 2023/11/24 00:15:42 asou Exp $ */
|
||||
/* $OpenBSD: kern_physio.c,v 1.49 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: kern_physio.c,v 1.28 1997/05/19 10:43:28 pk Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -84,7 +84,6 @@ physio(void (*strategy)(struct buf *), dev_t dev, int flags,
|
|||
bp->b_error = 0;
|
||||
bp->b_proc = p;
|
||||
bp->b_flags = B_BUSY;
|
||||
LIST_INIT(&bp->b_dep);
|
||||
splx(s);
|
||||
|
||||
/*
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: spec_vnops.c,v 1.111 2022/12/05 23:18:37 deraadt Exp $ */
|
||||
/* $OpenBSD: spec_vnops.c,v 1.112 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: spec_vnops.c,v 1.29 1996/04/22 01:42:38 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -444,9 +444,6 @@ spec_strategy(void *v)
|
|||
struct buf *bp = ap->a_bp;
|
||||
int maj = major(bp->b_dev);
|
||||
|
||||
if (LIST_FIRST(&bp->b_dep) != NULL)
|
||||
buf_start(bp);
|
||||
|
||||
(*bdevsw[maj].d_strategy)(bp);
|
||||
return (0);
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: uipc_socket.c,v 1.315 2024/01/26 18:24:23 mvs Exp $ */
|
||||
/* $OpenBSD: uipc_socket.c,v 1.316 2024/02/03 22:50:08 mvs Exp $ */
|
||||
/* $NetBSD: uipc_socket.c,v 1.21 1996/02/04 02:17:52 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -72,26 +72,20 @@ int filt_soread(struct knote *kn, long hint);
|
|||
void filt_sowdetach(struct knote *kn);
|
||||
int filt_sowrite(struct knote *kn, long hint);
|
||||
int filt_soexcept(struct knote *kn, long hint);
|
||||
int filt_solisten(struct knote *kn, long hint);
|
||||
int filt_somodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_soprocess(struct knote *kn, struct kevent *kev);
|
||||
|
||||
const struct filterops solisten_filtops = {
|
||||
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
|
||||
.f_attach = NULL,
|
||||
.f_detach = filt_sordetach,
|
||||
.f_event = filt_solisten,
|
||||
.f_modify = filt_somodify,
|
||||
.f_process = filt_soprocess,
|
||||
};
|
||||
int filt_sowmodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_sowprocess(struct knote *kn, struct kevent *kev);
|
||||
|
||||
int filt_sormodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_sorprocess(struct knote *kn, struct kevent *kev);
|
||||
|
||||
const struct filterops soread_filtops = {
|
||||
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
|
||||
.f_attach = NULL,
|
||||
.f_detach = filt_sordetach,
|
||||
.f_event = filt_soread,
|
||||
.f_modify = filt_somodify,
|
||||
.f_process = filt_soprocess,
|
||||
.f_modify = filt_sormodify,
|
||||
.f_process = filt_sorprocess,
|
||||
};
|
||||
|
||||
const struct filterops sowrite_filtops = {
|
||||
|
@ -99,8 +93,8 @@ const struct filterops sowrite_filtops = {
|
|||
.f_attach = NULL,
|
||||
.f_detach = filt_sowdetach,
|
||||
.f_event = filt_sowrite,
|
||||
.f_modify = filt_somodify,
|
||||
.f_process = filt_soprocess,
|
||||
.f_modify = filt_sowmodify,
|
||||
.f_process = filt_sowprocess,
|
||||
};
|
||||
|
||||
const struct filterops soexcept_filtops = {
|
||||
|
@ -108,18 +102,8 @@ const struct filterops soexcept_filtops = {
|
|||
.f_attach = NULL,
|
||||
.f_detach = filt_sordetach,
|
||||
.f_event = filt_soexcept,
|
||||
.f_modify = filt_somodify,
|
||||
.f_process = filt_soprocess,
|
||||
};
|
||||
|
||||
void klist_soassertlk(void *);
|
||||
int klist_solock(void *);
|
||||
void klist_sounlock(void *, int);
|
||||
|
||||
const struct klistops socket_klistops = {
|
||||
.klo_assertlk = klist_soassertlk,
|
||||
.klo_lock = klist_solock,
|
||||
.klo_unlock = klist_sounlock,
|
||||
.f_modify = filt_sormodify,
|
||||
.f_process = filt_sorprocess,
|
||||
};
|
||||
|
||||
#ifndef SOMINCONN
|
||||
|
@ -158,8 +142,10 @@ soalloc(const struct domain *dp, int wait)
|
|||
return (NULL);
|
||||
rw_init_flags(&so->so_lock, dp->dom_name, RWL_DUPOK);
|
||||
refcnt_init(&so->so_refcnt);
|
||||
klist_init(&so->so_rcv.sb_klist, &socket_klistops, so);
|
||||
klist_init(&so->so_snd.sb_klist, &socket_klistops, so);
|
||||
mtx_init(&so->so_rcv.sb_mtx, IPL_MPFLOOR);
|
||||
mtx_init(&so->so_snd.sb_mtx, IPL_MPFLOOR);
|
||||
klist_init_mutex(&so->so_rcv.sb_klist, &so->so_rcv.sb_mtx);
|
||||
klist_init_mutex(&so->so_snd.sb_klist, &so->so_snd.sb_mtx);
|
||||
sigio_init(&so->so_sigio);
|
||||
TAILQ_INIT(&so->so_q0);
|
||||
TAILQ_INIT(&so->so_q);
|
||||
|
@ -1757,7 +1743,7 @@ somove(struct socket *so, int wait)
|
|||
void
|
||||
sorwakeup(struct socket *so)
|
||||
{
|
||||
soassertlocked(so);
|
||||
soassertlocked_readonly(so);
|
||||
|
||||
#ifdef SOCKET_SPLICE
|
||||
if (so->so_rcv.sb_flags & SB_SPLICE) {
|
||||
|
@ -1785,7 +1771,7 @@ sorwakeup(struct socket *so)
|
|||
void
|
||||
sowwakeup(struct socket *so)
|
||||
{
|
||||
soassertlocked(so);
|
||||
soassertlocked_readonly(so);
|
||||
|
||||
#ifdef SOCKET_SPLICE
|
||||
if (so->so_snd.sb_flags & SB_SPLICE)
|
||||
|
@ -2134,7 +2120,46 @@ void
|
|||
sohasoutofband(struct socket *so)
|
||||
{
|
||||
pgsigio(&so->so_sigio, SIGURG, 0);
|
||||
knote_locked(&so->so_rcv.sb_klist, 0);
|
||||
knote(&so->so_rcv.sb_klist, 0);
|
||||
}
|
||||
|
||||
void
|
||||
sofilt_lock(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
switch (so->so_proto->pr_domain->dom_family) {
|
||||
case PF_INET:
|
||||
case PF_INET6:
|
||||
NET_LOCK_SHARED();
|
||||
break;
|
||||
default:
|
||||
rw_enter_write(&so->so_lock);
|
||||
break;
|
||||
}
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
}
|
||||
|
||||
void
|
||||
sofilt_unlock(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
switch (so->so_proto->pr_domain->dom_family) {
|
||||
case PF_INET:
|
||||
case PF_INET6:
|
||||
NET_UNLOCK_SHARED();
|
||||
break;
|
||||
default:
|
||||
rw_exit_write(&so->so_lock);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
sofilt_assert_locked(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
MUTEX_ASSERT_LOCKED(&sb->sb_mtx);
|
||||
soassertlocked_readonly(so);
|
||||
}
|
||||
|
||||
int
|
||||
|
@ -2143,13 +2168,9 @@ soo_kqfilter(struct file *fp, struct knote *kn)
|
|||
struct socket *so = kn->kn_fp->f_data;
|
||||
struct sockbuf *sb;
|
||||
|
||||
solock(so);
|
||||
switch (kn->kn_filter) {
|
||||
case EVFILT_READ:
|
||||
if (so->so_options & SO_ACCEPTCONN)
|
||||
kn->kn_fop = &solisten_filtops;
|
||||
else
|
||||
kn->kn_fop = &soread_filtops;
|
||||
kn->kn_fop = &soread_filtops;
|
||||
sb = &so->so_rcv;
|
||||
break;
|
||||
case EVFILT_WRITE:
|
||||
|
@ -2161,12 +2182,10 @@ soo_kqfilter(struct file *fp, struct knote *kn)
|
|||
sb = &so->so_rcv;
|
||||
break;
|
||||
default:
|
||||
sounlock(so);
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
klist_insert_locked(&sb->sb_klist, kn);
|
||||
sounlock(so);
|
||||
klist_insert(&sb->sb_klist, kn);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
@ -2185,7 +2204,23 @@ filt_soread(struct knote *kn, long hint)
|
|||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv = 0;
|
||||
|
||||
soassertlocked(so);
|
||||
sofilt_assert_locked(so, &so->so_rcv);
|
||||
|
||||
if (so->so_options & SO_ACCEPTCONN) {
|
||||
kn->kn_data = so->so_qlen;
|
||||
rv = (kn->kn_data != 0);
|
||||
|
||||
if (kn->kn_flags & (__EV_POLL | __EV_SELECT)) {
|
||||
if (so->so_state & SS_ISDISCONNECTED) {
|
||||
kn->kn_flags |= __EV_HUP;
|
||||
rv = 1;
|
||||
} else {
|
||||
rv = soreadable(so);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
kn->kn_data = so->so_rcv.sb_cc;
|
||||
#ifdef SOCKET_SPLICE
|
||||
|
@ -2226,7 +2261,7 @@ filt_sowrite(struct knote *kn, long hint)
|
|||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv;
|
||||
|
||||
soassertlocked(so);
|
||||
sofilt_assert_locked(so, &so->so_snd);
|
||||
|
||||
kn->kn_data = sbspace(so, &so->so_snd);
|
||||
if (so->so_snd.sb_state & SS_CANTSENDMORE) {
|
||||
|
@ -2257,7 +2292,7 @@ filt_soexcept(struct knote *kn, long hint)
|
|||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv = 0;
|
||||
|
||||
soassertlocked(so);
|
||||
sofilt_assert_locked(so, &so->so_rcv);
|
||||
|
||||
#ifdef SOCKET_SPLICE
|
||||
if (isspliced(so)) {
|
||||
|
@ -2283,77 +2318,55 @@ filt_soexcept(struct knote *kn, long hint)
|
|||
}
|
||||
|
||||
int
|
||||
filt_solisten(struct knote *kn, long hint)
|
||||
{
|
||||
struct socket *so = kn->kn_fp->f_data;
|
||||
int active;
|
||||
|
||||
soassertlocked(so);
|
||||
|
||||
kn->kn_data = so->so_qlen;
|
||||
active = (kn->kn_data != 0);
|
||||
|
||||
if (kn->kn_flags & (__EV_POLL | __EV_SELECT)) {
|
||||
if (so->so_state & SS_ISDISCONNECTED) {
|
||||
kn->kn_flags |= __EV_HUP;
|
||||
active = 1;
|
||||
} else {
|
||||
active = soreadable(so);
|
||||
}
|
||||
}
|
||||
|
||||
return (active);
|
||||
}
|
||||
|
||||
int
|
||||
filt_somodify(struct kevent *kev, struct knote *kn)
|
||||
filt_sowmodify(struct kevent *kev, struct knote *kn)
|
||||
{
|
||||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
sofilt_lock(so, &so->so_snd);
|
||||
rv = knote_modify(kev, kn);
|
||||
sounlock(so);
|
||||
sofilt_unlock(so, &so->so_snd);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
filt_soprocess(struct knote *kn, struct kevent *kev)
|
||||
filt_sowprocess(struct knote *kn, struct kevent *kev)
|
||||
{
|
||||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
sofilt_lock(so, &so->so_snd);
|
||||
rv = knote_process(kn, kev);
|
||||
sounlock(so);
|
||||
sofilt_unlock(so, &so->so_snd);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
void
|
||||
klist_soassertlk(void *arg)
|
||||
int
|
||||
filt_sormodify(struct kevent *kev, struct knote *kn)
|
||||
{
|
||||
struct socket *so = arg;
|
||||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv;
|
||||
|
||||
soassertlocked(so);
|
||||
sofilt_lock(so, &so->so_rcv);
|
||||
rv = knote_modify(kev, kn);
|
||||
sofilt_unlock(so, &so->so_rcv);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
klist_solock(void *arg)
|
||||
filt_sorprocess(struct knote *kn, struct kevent *kev)
|
||||
{
|
||||
struct socket *so = arg;
|
||||
struct socket *so = kn->kn_fp->f_data;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
return (1);
|
||||
}
|
||||
sofilt_lock(so, &so->so_rcv);
|
||||
rv = knote_process(kn, kev);
|
||||
sofilt_unlock(so, &so->so_rcv);
|
||||
|
||||
void
|
||||
klist_sounlock(void *arg, int ls)
|
||||
{
|
||||
struct socket *so = arg;
|
||||
|
||||
sounlock(so);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
#ifdef DDB
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: uipc_socket2.c,v 1.140 2024/01/11 14:15:11 bluhm Exp $ */
|
||||
/* $OpenBSD: uipc_socket2.c,v 1.141 2024/02/03 22:50:08 mvs Exp $ */
|
||||
/* $NetBSD: uipc_socket2.c,v 1.11 1996/02/04 02:17:55 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -439,7 +439,7 @@ sounlock_shared(struct socket *so)
|
|||
}
|
||||
|
||||
void
|
||||
soassertlocked(struct socket *so)
|
||||
soassertlocked_readonly(struct socket *so)
|
||||
{
|
||||
switch (so->so_proto->pr_domain->dom_family) {
|
||||
case PF_INET:
|
||||
|
@ -452,6 +452,27 @@ soassertlocked(struct socket *so)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
soassertlocked(struct socket *so)
|
||||
{
|
||||
switch (so->so_proto->pr_domain->dom_family) {
|
||||
case PF_INET:
|
||||
case PF_INET6:
|
||||
if (rw_status(&netlock) == RW_READ) {
|
||||
NET_ASSERT_LOCKED();
|
||||
|
||||
if (splassert_ctl > 0 && pru_locked(so) == 0 &&
|
||||
rw_status(&so->so_lock) != RW_WRITE)
|
||||
splassert_fail(0, RW_WRITE, __func__);
|
||||
} else
|
||||
NET_ASSERT_LOCKED_EXCLUSIVE();
|
||||
break;
|
||||
default:
|
||||
rw_assert_wrlock(&so->so_lock);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
sosleep_nsec(struct socket *so, void *ident, int prio, const char *wmesg,
|
||||
uint64_t nsecs)
|
||||
|
@ -489,46 +510,62 @@ sbwait(struct socket *so, struct sockbuf *sb)
|
|||
|
||||
soassertlocked(so);
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
sb->sb_flags |= SB_WAIT;
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
return sosleep_nsec(so, &sb->sb_cc, prio, "netio", sb->sb_timeo_nsecs);
|
||||
}
|
||||
|
||||
int
|
||||
sblock(struct socket *so, struct sockbuf *sb, int flags)
|
||||
{
|
||||
int error, prio = PSOCK;
|
||||
int error = 0, prio = PSOCK;
|
||||
|
||||
soassertlocked(so);
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
if ((sb->sb_flags & SB_LOCK) == 0) {
|
||||
sb->sb_flags |= SB_LOCK;
|
||||
return (0);
|
||||
goto out;
|
||||
}
|
||||
if ((flags & SBL_WAIT) == 0) {
|
||||
error = EWOULDBLOCK;
|
||||
goto out;
|
||||
}
|
||||
if ((flags & SBL_WAIT) == 0)
|
||||
return (EWOULDBLOCK);
|
||||
if (!(flags & SBL_NOINTR || sb->sb_flags & SB_NOINTR))
|
||||
prio |= PCATCH;
|
||||
|
||||
while (sb->sb_flags & SB_LOCK) {
|
||||
sb->sb_flags |= SB_WANT;
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
error = sosleep_nsec(so, &sb->sb_flags, prio, "netlck", INFSLP);
|
||||
if (error)
|
||||
return (error);
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
}
|
||||
sb->sb_flags |= SB_LOCK;
|
||||
return (0);
|
||||
out:
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
void
|
||||
sbunlock(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
soassertlocked(so);
|
||||
int dowakeup = 0;
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
sb->sb_flags &= ~SB_LOCK;
|
||||
if (sb->sb_flags & SB_WANT) {
|
||||
sb->sb_flags &= ~SB_WANT;
|
||||
wakeup(&sb->sb_flags);
|
||||
dowakeup = 1;
|
||||
}
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
if (dowakeup)
|
||||
wakeup(&sb->sb_flags);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -539,15 +576,24 @@ sbunlock(struct socket *so, struct sockbuf *sb)
|
|||
void
|
||||
sowakeup(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
soassertlocked(so);
|
||||
int dowakeup = 0, dopgsigio = 0;
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
if (sb->sb_flags & SB_WAIT) {
|
||||
sb->sb_flags &= ~SB_WAIT;
|
||||
wakeup(&sb->sb_cc);
|
||||
dowakeup = 1;
|
||||
}
|
||||
if (sb->sb_flags & SB_ASYNC)
|
||||
pgsigio(&so->so_sigio, SIGIO, 0);
|
||||
dopgsigio = 1;
|
||||
|
||||
knote_locked(&sb->sb_klist, 0);
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
if (dowakeup)
|
||||
wakeup(&sb->sb_cc);
|
||||
|
||||
if (dopgsigio)
|
||||
pgsigio(&so->so_sigio, SIGIO, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: uipc_syscalls.c,v 1.216 2024/01/03 11:07:04 bluhm Exp $ */
|
||||
/* $OpenBSD: uipc_syscalls.c,v 1.217 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: uipc_syscalls.c,v 1.19 1996/02/09 19:00:48 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -326,7 +326,7 @@ doaccept(struct proc *p, int sock, struct sockaddr *name, socklen_t *anamelen,
|
|||
: (flags & SOCK_NONBLOCK ? FNONBLOCK : 0);
|
||||
|
||||
/* connection has been removed from the listen queue */
|
||||
knote_locked(&head->so_rcv.sb_klist, 0);
|
||||
knote(&head->so_rcv.sb_klist, 0);
|
||||
|
||||
if (persocket)
|
||||
sounlock(head);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: vfs_bio.c,v 1.212 2023/04/26 15:13:52 beck Exp $ */
|
||||
/* $OpenBSD: vfs_bio.c,v 1.213 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: vfs_bio.c,v 1.44 1996/06/11 11:15:36 pk Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -65,7 +65,6 @@ int fliphigh;
|
|||
|
||||
int nobuffers;
|
||||
int needbuffer;
|
||||
struct bio_ops bioops;
|
||||
|
||||
/* private bufcache functions */
|
||||
void bufcache_init(void);
|
||||
|
@ -120,8 +119,6 @@ buf_put(struct buf *bp)
|
|||
if (bp->b_vnbufs.le_next != NOLIST &&
|
||||
bp->b_vnbufs.le_next != (void *)-1)
|
||||
panic("buf_put: still on the vnode list");
|
||||
if (!LIST_EMPTY(&bp->b_dep))
|
||||
panic("buf_put: b_dep is not empty");
|
||||
#endif
|
||||
|
||||
LIST_REMOVE(bp, b_list);
|
||||
|
@ -879,13 +876,6 @@ brelse(struct buf *bp)
|
|||
if (bp->b_data != NULL)
|
||||
KASSERT(bp->b_bufsize > 0);
|
||||
|
||||
/*
|
||||
* softdep is basically incompatible with not caching buffers
|
||||
* that have dependencies, so this buffer must be cached
|
||||
*/
|
||||
if (LIST_FIRST(&bp->b_dep) != NULL)
|
||||
CLR(bp->b_flags, B_NOCACHE);
|
||||
|
||||
/*
|
||||
* Determine which queue the buffer should be on, then put it there.
|
||||
*/
|
||||
|
@ -904,9 +894,6 @@ brelse(struct buf *bp)
|
|||
* If the buffer is invalid, free it now rather than leaving
|
||||
* it in a queue and wasting memory.
|
||||
*/
|
||||
if (LIST_FIRST(&bp->b_dep) != NULL)
|
||||
buf_deallocate(bp);
|
||||
|
||||
if (ISSET(bp->b_flags, B_DELWRI)) {
|
||||
CLR(bp->b_flags, B_DELWRI);
|
||||
}
|
||||
|
@ -1150,7 +1137,6 @@ buf_get(struct vnode *vp, daddr_t blkno, size_t size)
|
|||
|
||||
bp->b_freelist.tqe_next = NOLIST;
|
||||
bp->b_dev = NODEV;
|
||||
LIST_INIT(&bp->b_dep);
|
||||
bp->b_bcount = size;
|
||||
|
||||
buf_acquire_nomap(bp);
|
||||
|
@ -1243,16 +1229,6 @@ buf_daemon(void *arg)
|
|||
if (!ISSET(bp->b_flags, B_DELWRI))
|
||||
panic("Clean buffer on dirty queue");
|
||||
#endif
|
||||
if (LIST_FIRST(&bp->b_dep) != NULL &&
|
||||
!ISSET(bp->b_flags, B_DEFERRED) &&
|
||||
buf_countdeps(bp, 0, 0)) {
|
||||
SET(bp->b_flags, B_DEFERRED);
|
||||
s = splbio();
|
||||
bufcache_release(bp);
|
||||
buf_release(bp);
|
||||
continue;
|
||||
}
|
||||
|
||||
bawrite(bp);
|
||||
pushed++;
|
||||
|
||||
|
@ -1321,9 +1297,6 @@ biodone(struct buf *bp)
|
|||
if (bp->b_bq)
|
||||
bufq_done(bp->b_bq, bp);
|
||||
|
||||
if (LIST_FIRST(&bp->b_dep) != NULL)
|
||||
buf_complete(bp);
|
||||
|
||||
if (!ISSET(bp->b_flags, B_READ)) {
|
||||
CLR(bp->b_flags, B_WRITEINPROG);
|
||||
vwakeup(bp->b_vp);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: vfs_subr.c,v 1.318 2022/12/26 19:25:49 miod Exp $ */
|
||||
/* $OpenBSD: vfs_subr.c,v 1.319 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: vfs_subr.c,v 1.53 1996/04/22 01:39:13 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -1819,6 +1819,10 @@ vfs_syncwait(struct proc *p, int verbose)
|
|||
* With soft updates, some buffers that are
|
||||
* written will be remarked as dirty until other
|
||||
* buffers are written.
|
||||
*
|
||||
* XXX here be dragons. this should really go away
|
||||
* but should be carefully made to go away on it's
|
||||
* own with testing.. XXX
|
||||
*/
|
||||
if (bp->b_flags & B_DELWRI) {
|
||||
s = splbio();
|
||||
|
@ -2249,18 +2253,14 @@ vfs_buf_print(void *b, int full,
|
|||
bp->b_proc, bp->b_error, bp->b_flags, B_BITS);
|
||||
|
||||
(*pr)(" bufsize 0x%lx bcount 0x%lx resid 0x%lx\n"
|
||||
" data %p saveaddr %p dep %p iodone %p\n",
|
||||
" data %p saveaddr %p iodone %p\n",
|
||||
bp->b_bufsize, bp->b_bcount, (long)bp->b_resid,
|
||||
bp->b_data, bp->b_saveaddr,
|
||||
LIST_FIRST(&bp->b_dep), bp->b_iodone);
|
||||
bp->b_iodone);
|
||||
|
||||
(*pr)(" dirty {off 0x%x end 0x%x} valid {off 0x%x end 0x%x}\n",
|
||||
bp->b_dirtyoff, bp->b_dirtyend, bp->b_validoff, bp->b_validend);
|
||||
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
if (full)
|
||||
softdep_print(bp, full, pr);
|
||||
#endif
|
||||
}
|
||||
|
||||
const char *vtypes[] = { VTYPE_NAMES };
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: vfs_sync.c,v 1.69 2023/05/25 07:45:33 claudio Exp $ */
|
||||
/* $OpenBSD: vfs_sync.c,v 1.70 2024/02/03 18:51:58 beck Exp $ */
|
||||
|
||||
/*
|
||||
* Portions of this code are:
|
||||
|
@ -50,10 +50,6 @@
|
|||
#include <sys/malloc.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
int softdep_process_worklist(struct mount *);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The workitem queue.
|
||||
*/
|
||||
|
@ -62,9 +58,6 @@ int softdep_process_worklist(struct mount *);
|
|||
int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */
|
||||
int syncdelay = SYNCER_DEFAULT; /* time to delay syncing vnodes */
|
||||
|
||||
int rushjob = 0; /* number of slots to run ASAP */
|
||||
int stat_rush_requests = 0; /* number of rush requests */
|
||||
|
||||
int syncer_delayno = 0;
|
||||
long syncer_mask;
|
||||
LIST_HEAD(synclist, vnode);
|
||||
|
@ -198,28 +191,6 @@ syncer_thread(void *arg)
|
|||
|
||||
splx(s);
|
||||
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
/*
|
||||
* Do soft update processing.
|
||||
*/
|
||||
softdep_process_worklist(NULL);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The variable rushjob allows the kernel to speed up the
|
||||
* processing of the filesystem syncer process. A rushjob
|
||||
* value of N tells the filesystem syncer to process the next
|
||||
* N seconds worth of work on its queue ASAP. Currently rushjob
|
||||
* is used by the soft update code to speed up the filesystem
|
||||
* syncer process when the incore state is getting so far
|
||||
* ahead of the disk that the kernel memory pool is being
|
||||
* threatened with exhaustion.
|
||||
*/
|
||||
if (rushjob > 0) {
|
||||
rushjob -= 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* If it has taken us less than a second to process the
|
||||
* current work, then wait. Otherwise start right over
|
||||
|
@ -236,24 +207,6 @@ syncer_thread(void *arg)
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Request the syncer daemon to speed up its work.
|
||||
* We never push it to speed up more than half of its
|
||||
* normal turn time, otherwise it could take over the cpu.
|
||||
*/
|
||||
int
|
||||
speedup_syncer(void)
|
||||
{
|
||||
if (syncerproc)
|
||||
wakeup_one(&syncer_chan);
|
||||
if (rushjob < syncdelay / 2) {
|
||||
rushjob += 1;
|
||||
stat_rush_requests += 1;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Routine to create and manage a filesystem syncer vnode. */
|
||||
int sync_fsync(void *);
|
||||
int sync_inactive(void *);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: vfs_syscalls.c,v 1.362 2023/07/05 15:13:28 beck Exp $ */
|
||||
/* $OpenBSD: vfs_syscalls.c,v 1.363 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: vfs_syscalls.c,v 1.71 1996/04/23 10:29:02 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -2894,10 +2894,6 @@ sys_fsync(struct proc *p, void *v, register_t *retval)
|
|||
vp = fp->f_data;
|
||||
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
||||
error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP))
|
||||
error = softdep_fsync(vp);
|
||||
#endif
|
||||
|
||||
VOP_UNLOCK(vp);
|
||||
FRELE(fp, p);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: fifo_vnops.c,v 1.102 2023/03/08 04:43:08 guenther Exp $ */
|
||||
/* $OpenBSD: fifo_vnops.c,v 1.103 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: fifo_vnops.c,v 1.18 1996/03/16 23:52:42 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -105,16 +105,18 @@ int filt_fiforead(struct knote *kn, long hint);
|
|||
void filt_fifowdetach(struct knote *kn);
|
||||
int filt_fifowrite(struct knote *kn, long hint);
|
||||
int filt_fifoexcept(struct knote *kn, long hint);
|
||||
int filt_fifomodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_fifoprocess(struct knote *kn, struct kevent *kev);
|
||||
int filt_fiformodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_fiforprocess(struct knote *kn, struct kevent *kev);
|
||||
int filt_fifowmodify(struct kevent *kev, struct knote *kn);
|
||||
int filt_fifowprocess(struct knote *kn, struct kevent *kev);
|
||||
|
||||
const struct filterops fiforead_filtops = {
|
||||
.f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
|
||||
.f_attach = NULL,
|
||||
.f_detach = filt_fifordetach,
|
||||
.f_event = filt_fiforead,
|
||||
.f_modify = filt_fifomodify,
|
||||
.f_process = filt_fifoprocess,
|
||||
.f_modify = filt_fiformodify,
|
||||
.f_process = filt_fiforprocess,
|
||||
};
|
||||
|
||||
const struct filterops fifowrite_filtops = {
|
||||
|
@ -122,8 +124,8 @@ const struct filterops fifowrite_filtops = {
|
|||
.f_attach = NULL,
|
||||
.f_detach = filt_fifowdetach,
|
||||
.f_event = filt_fifowrite,
|
||||
.f_modify = filt_fifomodify,
|
||||
.f_process = filt_fifoprocess,
|
||||
.f_modify = filt_fifowmodify,
|
||||
.f_process = filt_fifowprocess,
|
||||
};
|
||||
|
||||
const struct filterops fifoexcept_filtops = {
|
||||
|
@ -131,8 +133,8 @@ const struct filterops fifoexcept_filtops = {
|
|||
.f_attach = NULL,
|
||||
.f_detach = filt_fifordetach,
|
||||
.f_event = filt_fifoexcept,
|
||||
.f_modify = filt_fifomodify,
|
||||
.f_process = filt_fifoprocess,
|
||||
.f_modify = filt_fiformodify,
|
||||
.f_process = filt_fiforprocess,
|
||||
};
|
||||
|
||||
/*
|
||||
|
@ -517,6 +519,7 @@ filt_fiforead(struct knote *kn, long hint)
|
|||
int rv;
|
||||
|
||||
soassertlocked(so);
|
||||
MUTEX_ASSERT_LOCKED(&so->so_rcv.sb_mtx);
|
||||
|
||||
kn->kn_data = so->so_rcv.sb_cc;
|
||||
if (so->so_rcv.sb_state & SS_CANTRCVMORE) {
|
||||
|
@ -551,6 +554,7 @@ filt_fifowrite(struct knote *kn, long hint)
|
|||
int rv;
|
||||
|
||||
soassertlocked(so);
|
||||
MUTEX_ASSERT_LOCKED(&so->so_snd.sb_mtx);
|
||||
|
||||
kn->kn_data = sbspace(so, &so->so_snd);
|
||||
if (so->so_snd.sb_state & SS_CANTSENDMORE) {
|
||||
|
@ -571,6 +575,7 @@ filt_fifoexcept(struct knote *kn, long hint)
|
|||
int rv = 0;
|
||||
|
||||
soassertlocked(so);
|
||||
MUTEX_ASSERT_LOCKED(&so->so_rcv.sb_mtx);
|
||||
|
||||
if (kn->kn_flags & __EV_POLL) {
|
||||
if (so->so_state & SS_ISDISCONNECTED) {
|
||||
|
@ -585,26 +590,60 @@ filt_fifoexcept(struct knote *kn, long hint)
|
|||
}
|
||||
|
||||
int
|
||||
filt_fifomodify(struct kevent *kev, struct knote *kn)
|
||||
filt_fiformodify(struct kevent *kev, struct knote *kn)
|
||||
{
|
||||
struct socket *so = kn->kn_hook;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
mtx_enter(&so->so_rcv.sb_mtx);
|
||||
rv = knote_modify(kev, kn);
|
||||
mtx_leave(&so->so_rcv.sb_mtx);
|
||||
sounlock(so);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
filt_fifoprocess(struct knote *kn, struct kevent *kev)
|
||||
filt_fiforprocess(struct knote *kn, struct kevent *kev)
|
||||
{
|
||||
struct socket *so = kn->kn_hook;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
mtx_enter(&so->so_rcv.sb_mtx);
|
||||
rv = knote_process(kn, kev);
|
||||
mtx_leave(&so->so_rcv.sb_mtx);
|
||||
sounlock(so);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
filt_fifowmodify(struct kevent *kev, struct knote *kn)
|
||||
{
|
||||
struct socket *so = kn->kn_hook;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
mtx_enter(&so->so_snd.sb_mtx);
|
||||
rv = knote_modify(kev, kn);
|
||||
mtx_leave(&so->so_snd.sb_mtx);
|
||||
sounlock(so);
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
filt_fifowprocess(struct knote *kn, struct kevent *kev)
|
||||
{
|
||||
struct socket *so = kn->kn_hook;
|
||||
int rv;
|
||||
|
||||
solock(so);
|
||||
mtx_enter(&so->so_snd.sb_mtx);
|
||||
rv = knote_process(kn, kev);
|
||||
mtx_leave(&so->so_snd.sb_mtx);
|
||||
sounlock(so);
|
||||
|
||||
return (rv);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip_divert.c,v 1.92 2023/09/16 09:33:27 mpi Exp $ */
|
||||
/* $OpenBSD: ip_divert.c,v 1.93 2024/02/03 22:50:09 mvs Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
|
||||
|
@ -67,6 +67,7 @@ const struct pr_usrreqs divert_usrreqs = {
|
|||
.pru_detach = divert_detach,
|
||||
.pru_lock = divert_lock,
|
||||
.pru_unlock = divert_unlock,
|
||||
.pru_locked = divert_locked,
|
||||
.pru_bind = divert_bind,
|
||||
.pru_shutdown = divert_shutdown,
|
||||
.pru_send = divert_send,
|
||||
|
@ -313,6 +314,14 @@ divert_unlock(struct socket *so)
|
|||
mtx_leave(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
divert_locked(struct socket *so)
|
||||
{
|
||||
struct inpcb *inp = sotoinpcb(so);
|
||||
|
||||
return mtx_owned(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
divert_bind(struct socket *so, struct mbuf *addr, struct proc *p)
|
||||
{
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip_divert.h,v 1.24 2022/10/17 14:49:02 mvs Exp $ */
|
||||
/* $OpenBSD: ip_divert.h,v 1.25 2024/02/03 22:50:09 mvs Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
|
||||
|
@ -74,6 +74,7 @@ int divert_attach(struct socket *, int, int);
|
|||
int divert_detach(struct socket *);
|
||||
void divert_lock(struct socket *);
|
||||
void divert_unlock(struct socket *);
|
||||
int divert_locked(struct socket *);
|
||||
int divert_bind(struct socket *, struct mbuf *, struct proc *);
|
||||
int divert_shutdown(struct socket *);
|
||||
int divert_send(struct socket *, struct mbuf *, struct mbuf *,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip_var.h,v 1.110 2023/11/26 22:08:10 bluhm Exp $ */
|
||||
/* $OpenBSD: ip_var.h,v 1.111 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: ip_var.h,v 1.16 1996/02/13 23:43:20 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -260,6 +260,7 @@ int rip_attach(struct socket *, int, int);
|
|||
int rip_detach(struct socket *);
|
||||
void rip_lock(struct socket *);
|
||||
void rip_unlock(struct socket *);
|
||||
int rip_locked(struct socket *);
|
||||
int rip_bind(struct socket *, struct mbuf *, struct proc *);
|
||||
int rip_connect(struct socket *, struct mbuf *);
|
||||
int rip_disconnect(struct socket *);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: raw_ip.c,v 1.154 2024/01/21 01:17:20 bluhm Exp $ */
|
||||
/* $OpenBSD: raw_ip.c,v 1.155 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: raw_ip.c,v 1.25 1996/02/18 18:58:33 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -108,6 +108,7 @@ const struct pr_usrreqs rip_usrreqs = {
|
|||
.pru_detach = rip_detach,
|
||||
.pru_lock = rip_lock,
|
||||
.pru_unlock = rip_unlock,
|
||||
.pru_locked = rip_locked,
|
||||
.pru_bind = rip_bind,
|
||||
.pru_connect = rip_connect,
|
||||
.pru_disconnect = rip_disconnect,
|
||||
|
@ -524,6 +525,14 @@ rip_unlock(struct socket *so)
|
|||
mtx_leave(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
rip_locked(struct socket *so)
|
||||
{
|
||||
struct inpcb *inp = sotoinpcb(so);
|
||||
|
||||
return mtx_owned(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
rip_bind(struct socket *so, struct mbuf *nam, struct proc *p)
|
||||
{
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: udp_usrreq.c,v 1.316 2024/01/28 20:34:25 bluhm Exp $ */
|
||||
/* $OpenBSD: udp_usrreq.c,v 1.317 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: udp_usrreq.c,v 1.28 1996/03/16 23:54:03 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -127,6 +127,7 @@ const struct pr_usrreqs udp_usrreqs = {
|
|||
.pru_detach = udp_detach,
|
||||
.pru_lock = udp_lock,
|
||||
.pru_unlock = udp_unlock,
|
||||
.pru_locked = udp_locked,
|
||||
.pru_bind = udp_bind,
|
||||
.pru_connect = udp_connect,
|
||||
.pru_disconnect = udp_disconnect,
|
||||
|
@ -143,6 +144,7 @@ const struct pr_usrreqs udp6_usrreqs = {
|
|||
.pru_detach = udp_detach,
|
||||
.pru_lock = udp_lock,
|
||||
.pru_unlock = udp_unlock,
|
||||
.pru_locked = udp_locked,
|
||||
.pru_bind = udp_bind,
|
||||
.pru_connect = udp_connect,
|
||||
.pru_disconnect = udp_disconnect,
|
||||
|
@ -1156,6 +1158,14 @@ udp_unlock(struct socket *so)
|
|||
mtx_leave(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
udp_locked(struct socket *so)
|
||||
{
|
||||
struct inpcb *inp = sotoinpcb(so);
|
||||
|
||||
return mtx_owned(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
udp_bind(struct socket *so, struct mbuf *addr, struct proc *p)
|
||||
{
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: udp_var.h,v 1.50 2024/01/10 16:44:30 bluhm Exp $ */
|
||||
/* $OpenBSD: udp_var.h,v 1.51 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: udp_var.h,v 1.12 1996/02/13 23:44:41 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -147,6 +147,7 @@ int udp_attach(struct socket *, int, int);
|
|||
int udp_detach(struct socket *);
|
||||
void udp_lock(struct socket *);
|
||||
void udp_unlock(struct socket *);
|
||||
int udp_locked(struct socket *);
|
||||
int udp_bind(struct socket *, struct mbuf *, struct proc *);
|
||||
int udp_connect(struct socket *, struct mbuf *);
|
||||
int udp_disconnect(struct socket *);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip6_divert.c,v 1.91 2024/01/01 18:52:09 bluhm Exp $ */
|
||||
/* $OpenBSD: ip6_divert.c,v 1.92 2024/02/03 22:50:09 mvs Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
|
||||
|
@ -69,6 +69,7 @@ const struct pr_usrreqs divert6_usrreqs = {
|
|||
.pru_detach = divert_detach,
|
||||
.pru_lock = divert_lock,
|
||||
.pru_unlock = divert_unlock,
|
||||
.pru_locked = divert_locked,
|
||||
.pru_bind = divert_bind,
|
||||
.pru_shutdown = divert_shutdown,
|
||||
.pru_send = divert6_send,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip6_mroute.c,v 1.138 2023/12/06 09:27:17 bluhm Exp $ */
|
||||
/* $OpenBSD: ip6_mroute.c,v 1.139 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: ip6_mroute.c,v 1.59 2003/12/10 09:28:38 itojun Exp $ */
|
||||
/* $KAME: ip6_mroute.c,v 1.45 2001/03/25 08:38:51 itojun Exp $ */
|
||||
|
||||
|
@ -861,12 +861,12 @@ socket6_send(struct socket *so, struct mbuf *mm, struct sockaddr_in6 *src)
|
|||
|
||||
mtx_enter(&inp->inp_mtx);
|
||||
ret = sbappendaddr(so, &so->so_rcv, sin6tosa(src), mm, NULL);
|
||||
if (ret != 0)
|
||||
sorwakeup(so);
|
||||
mtx_leave(&inp->inp_mtx);
|
||||
|
||||
if (ret != 0) {
|
||||
sorwakeup(so);
|
||||
if (ret != 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
m_freem(mm);
|
||||
return -1;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ip6_var.h,v 1.109 2023/12/03 20:36:24 bluhm Exp $ */
|
||||
/* $OpenBSD: ip6_var.h,v 1.110 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $KAME: ip6_var.h,v 1.33 2000/06/11 14:59:20 jinmei Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -353,6 +353,7 @@ int rip6_attach(struct socket *, int, int);
|
|||
int rip6_detach(struct socket *);
|
||||
void rip6_lock(struct socket *);
|
||||
void rip6_unlock(struct socket *);
|
||||
int rip6_locked(struct socket *);
|
||||
int rip6_bind(struct socket *, struct mbuf *, struct proc *);
|
||||
int rip6_connect(struct socket *, struct mbuf *);
|
||||
int rip6_disconnect(struct socket *);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: raw_ip6.c,v 1.179 2024/01/21 01:17:20 bluhm Exp $ */
|
||||
/* $OpenBSD: raw_ip6.c,v 1.180 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $KAME: raw_ip6.c,v 1.69 2001/03/04 15:55:44 itojun Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -110,6 +110,7 @@ const struct pr_usrreqs rip6_usrreqs = {
|
|||
.pru_detach = rip6_detach,
|
||||
.pru_lock = rip6_lock,
|
||||
.pru_unlock = rip6_unlock,
|
||||
.pru_locked = rip6_locked,
|
||||
.pru_bind = rip6_bind,
|
||||
.pru_connect = rip6_connect,
|
||||
.pru_disconnect = rip6_disconnect,
|
||||
|
@ -653,6 +654,14 @@ rip6_unlock(struct socket *so)
|
|||
mtx_leave(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
rip6_locked(struct socket *so)
|
||||
{
|
||||
struct inpcb *inp = sotoinpcb(so);
|
||||
|
||||
return mtx_owned(&inp->inp_mtx);
|
||||
}
|
||||
|
||||
int
|
||||
rip6_bind(struct socket *so, struct mbuf *nam, struct proc *p)
|
||||
{
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: buf.h,v 1.113 2022/09/01 05:24:51 jsg Exp $ */
|
||||
/* $OpenBSD: buf.h,v 1.114 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: buf.h,v 1.25 1997/04/09 21:12:17 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -51,12 +51,6 @@ struct vnode;
|
|||
|
||||
LIST_HEAD(bufhead, buf);
|
||||
|
||||
/*
|
||||
* To avoid including <ufs/ffs/softdep.h>
|
||||
*/
|
||||
|
||||
LIST_HEAD(workhead, worklist);
|
||||
|
||||
/*
|
||||
* Buffer queues
|
||||
*/
|
||||
|
@ -122,20 +116,6 @@ union bufq_data {
|
|||
struct bufq_nscan bufq_data_nscan;
|
||||
};
|
||||
|
||||
/*
|
||||
* These are currently used only by the soft dependency code, hence
|
||||
* are stored once in a global variable. If other subsystems wanted
|
||||
* to use these hooks, a pointer to a set of bio_ops could be added
|
||||
* to each buffer.
|
||||
*/
|
||||
extern struct bio_ops {
|
||||
void (*io_start)(struct buf *);
|
||||
void (*io_complete)(struct buf *);
|
||||
void (*io_deallocate)(struct buf *);
|
||||
void (*io_movedeps)(struct buf *, struct buf *);
|
||||
int (*io_countdeps)(struct buf *, int, int);
|
||||
} bioops;
|
||||
|
||||
/* The buffer header describes an I/O operation in the kernel. */
|
||||
struct buf {
|
||||
RBT_ENTRY(buf) b_rbbufs; /* vnode "hash" tree */
|
||||
|
@ -172,7 +152,6 @@ struct buf {
|
|||
int b_dirtyend; /* Offset of end of dirty region. */
|
||||
int b_validoff; /* Offset in buffer of valid region. */
|
||||
int b_validend; /* Offset of end of valid region. */
|
||||
struct workhead b_dep; /* List of filesystem dependencies. */
|
||||
};
|
||||
|
||||
TAILQ_HEAD(bufqueue, buf);
|
||||
|
@ -324,43 +303,6 @@ void buf_daemon(void *);
|
|||
void buf_replacevnode(struct buf *, struct vnode *);
|
||||
int bread_cluster(struct vnode *, daddr_t, int, struct buf **);
|
||||
|
||||
static __inline void
|
||||
buf_start(struct buf *bp)
|
||||
{
|
||||
if (bioops.io_start)
|
||||
(*bioops.io_start)(bp);
|
||||
}
|
||||
|
||||
static __inline void
|
||||
buf_complete(struct buf *bp)
|
||||
{
|
||||
if (bioops.io_complete)
|
||||
(*bioops.io_complete)(bp);
|
||||
}
|
||||
|
||||
static __inline void
|
||||
buf_deallocate(struct buf *bp)
|
||||
{
|
||||
if (bioops.io_deallocate)
|
||||
(*bioops.io_deallocate)(bp);
|
||||
}
|
||||
|
||||
static __inline void
|
||||
buf_movedeps(struct buf *bp, struct buf *bp2)
|
||||
{
|
||||
if (bioops.io_movedeps)
|
||||
(*bioops.io_movedeps)(bp, bp2);
|
||||
}
|
||||
|
||||
static __inline int
|
||||
buf_countdeps(struct buf *bp, int i, int islocked)
|
||||
{
|
||||
if (bioops.io_countdeps)
|
||||
return ((*bioops.io_countdeps)(bp, i, islocked));
|
||||
else
|
||||
return (0);
|
||||
}
|
||||
|
||||
__END_DECLS
|
||||
#endif /* _KERNEL */
|
||||
#endif /* !_SYS_BUF_H_ */
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: mount.h,v 1.150 2023/07/05 15:13:28 beck Exp $ */
|
||||
/* $OpenBSD: mount.h,v 1.151 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: mount.h,v 1.48 1996/02/18 11:55:47 fvdl Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -610,7 +610,6 @@ int vfs_export(struct mount *, struct netexport *, struct export_args *);
|
|||
struct netcred *vfs_export_lookup(struct mount *, struct netexport *,
|
||||
struct mbuf *);
|
||||
int vfs_allocate_syncvnode(struct mount *);
|
||||
int speedup_syncer(void);
|
||||
|
||||
int vfs_syncwait(struct proc *, int); /* sync and wait for complete */
|
||||
void vfs_shutdown(struct proc *); /* unmount and sync file systems */
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: mutex.h,v 1.19 2023/12/01 14:37:22 bluhm Exp $ */
|
||||
/* $OpenBSD: mutex.h,v 1.20 2024/02/03 22:50:09 mvs Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2004 Artur Grabowski <art@openbsd.org>
|
||||
|
@ -127,6 +127,9 @@ void mtx_leave(struct mutex *);
|
|||
|
||||
#define mtx_init(m, ipl) mtx_init_flags(m, ipl, NULL, 0)
|
||||
|
||||
#define mtx_owned(mtx) \
|
||||
(((mtx)->mtx_owner == curcpu()) || panicstr || db_active)
|
||||
|
||||
#ifdef WITNESS
|
||||
|
||||
void _mtx_init_flags(struct mutex *, int, const char *, int,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: proc.h,v 1.355 2024/01/19 01:43:27 bluhm Exp $ */
|
||||
/* $OpenBSD: proc.h,v 1.356 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: proc.h,v 1.44 1996/04/22 01:23:21 christos Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -436,7 +436,6 @@ struct proc {
|
|||
#define P_CONTINUED 0x00800000 /* Proc has continued from a stopped state. */
|
||||
#define P_THREAD 0x04000000 /* Only a thread, not a real process */
|
||||
#define P_SUSPSIG 0x08000000 /* Stopped from signal. */
|
||||
#define P_SOFTDEP 0x10000000 /* Stuck processing softdep worklist */
|
||||
#define P_CPUPEG 0x40000000 /* Do not move to another cpu. */
|
||||
|
||||
#define P_BITS \
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: protosw.h,v 1.64 2024/01/11 14:15:12 bluhm Exp $ */
|
||||
/* $OpenBSD: protosw.h,v 1.65 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: protosw.h,v 1.10 1996/04/09 20:55:32 cgd Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -69,6 +69,7 @@ struct pr_usrreqs {
|
|||
int (*pru_detach)(struct socket *);
|
||||
void (*pru_lock)(struct socket *);
|
||||
void (*pru_unlock)(struct socket *);
|
||||
int (*pru_locked)(struct socket *so);
|
||||
int (*pru_bind)(struct socket *, struct mbuf *, struct proc *);
|
||||
int (*pru_listen)(struct socket *);
|
||||
int (*pru_connect)(struct socket *, struct mbuf *);
|
||||
|
@ -296,6 +297,14 @@ pru_unlock(struct socket *so)
|
|||
(*so->so_proto->pr_usrreqs->pru_unlock)(so);
|
||||
}
|
||||
|
||||
static inline int
|
||||
pru_locked(struct socket *so)
|
||||
{
|
||||
if (so->so_proto->pr_usrreqs->pru_locked)
|
||||
return (*so->so_proto->pr_usrreqs->pru_locked)(so);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static inline int
|
||||
pru_bind(struct socket *so, struct mbuf *nam, struct proc *p)
|
||||
{
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: socketvar.h,v 1.121 2024/01/11 14:15:12 bluhm Exp $ */
|
||||
/* $OpenBSD: socketvar.h,v 1.122 2024/02/03 22:50:09 mvs Exp $ */
|
||||
/* $NetBSD: socketvar.h,v 1.18 1996/02/09 18:25:38 christos Exp $ */
|
||||
|
||||
/*-
|
||||
|
@ -40,6 +40,7 @@
|
|||
#include <sys/sigio.h> /* for struct sigio_ref */
|
||||
#include <sys/task.h>
|
||||
#include <sys/timeout.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/rwlock.h>
|
||||
#include <sys/refcnt.h>
|
||||
|
||||
|
@ -105,6 +106,7 @@ struct socket {
|
|||
* Variables for socket buffering.
|
||||
*/
|
||||
struct sockbuf {
|
||||
struct mutex sb_mtx;
|
||||
/* The following fields are all zeroed on flush. */
|
||||
#define sb_startzero sb_cc
|
||||
u_long sb_cc; /* actual chars in buffer */
|
||||
|
@ -174,6 +176,7 @@ struct socket {
|
|||
#include <lib/libkern/libkern.h>
|
||||
|
||||
void soassertlocked(struct socket *);
|
||||
void soassertlocked_readonly(struct socket *);
|
||||
|
||||
static inline void
|
||||
soref(struct socket *so)
|
||||
|
@ -200,9 +203,16 @@ sorele(struct socket *so)
|
|||
static inline int
|
||||
sb_notify(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
int rv;
|
||||
|
||||
soassertlocked(so);
|
||||
return ((sb->sb_flags & (SB_WAIT|SB_ASYNC|SB_SPLICE)) != 0 ||
|
||||
|
||||
mtx_enter(&sb->sb_mtx);
|
||||
rv = ((sb->sb_flags & (SB_WAIT|SB_ASYNC|SB_SPLICE)) != 0 ||
|
||||
!klist_empty(&sb->sb_klist));
|
||||
mtx_leave(&sb->sb_mtx);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -211,10 +221,12 @@ sb_notify(struct socket *so, struct sockbuf *sb)
|
|||
* still be negative (cc > hiwat or mbcnt > mbmax). Should detect
|
||||
* overflow and return 0.
|
||||
*/
|
||||
|
||||
static inline long
|
||||
sbspace(struct socket *so, struct sockbuf *sb)
|
||||
{
|
||||
soassertlocked(so);
|
||||
soassertlocked_readonly(so);
|
||||
|
||||
return lmin(sb->sb_hiwat - sb->sb_cc, sb->sb_mbmax - sb->sb_mbcnt);
|
||||
}
|
||||
|
||||
|
@ -230,7 +242,7 @@ sbspace(struct socket *so, struct sockbuf *sb)
|
|||
static inline int
|
||||
soreadable(struct socket *so)
|
||||
{
|
||||
soassertlocked(so);
|
||||
soassertlocked_readonly(so);
|
||||
if (isspliced(so))
|
||||
return 0;
|
||||
return (so->so_rcv.sb_state & SS_CANTRCVMORE) || so->so_qlen ||
|
||||
|
@ -241,7 +253,7 @@ soreadable(struct socket *so)
|
|||
static inline int
|
||||
sowriteable(struct socket *so)
|
||||
{
|
||||
soassertlocked(so);
|
||||
soassertlocked_readonly(so);
|
||||
return ((sbspace(so, &so->so_snd) >= so->so_snd.sb_lowat &&
|
||||
((so->so_state & SS_ISCONNECTED) ||
|
||||
(so->so_proto->pr_flags & PR_CONNREQUIRED)==0)) ||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: vnode.h,v 1.169 2023/09/08 20:00:28 mvs Exp $ */
|
||||
/* $OpenBSD: vnode.h,v 1.170 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: vnode.h,v 1.38 1996/02/29 20:59:05 cgd Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -643,7 +643,6 @@ void vn_syncer_add_to_worklist(struct vnode *, int);
|
|||
|
||||
/* misc */
|
||||
int vn_isdisk(struct vnode *, int *);
|
||||
int softdep_fsync(struct vnode *);
|
||||
int getvnode(struct proc *, int, struct file **);
|
||||
|
||||
/* uvm */
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_alloc.c,v 1.114 2021/03/11 13:31:35 jsg Exp $ */
|
||||
/* $OpenBSD: ffs_alloc.c,v 1.115 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_alloc.c,v 1.11 1996/05/11 18:27:09 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -291,8 +291,7 @@ ffs_realloccg(struct inode *ip, daddr_t lbprev, daddr_t bpref, int osize,
|
|||
goto nospace;
|
||||
|
||||
(void) uvm_vnp_uncache(ITOV(ip));
|
||||
if (!DOINGSOFTDEP(ITOV(ip)))
|
||||
ffs_blkfree(ip, bprev, (long)osize);
|
||||
ffs_blkfree(ip, bprev, (long)osize);
|
||||
if (nsize < request)
|
||||
ffs_blkfree(ip, bno + numfrags(fs, nsize),
|
||||
(long)(request - nsize));
|
||||
|
@ -921,8 +920,6 @@ ffs_fragextend(struct inode *ip, u_int cg, daddr_t bprev, int osize, int nsize)
|
|||
fs->fs_cs(fs, cg).cs_nffree--;
|
||||
}
|
||||
fs->fs_fmod = 1;
|
||||
if (DOINGSOFTDEP(ITOV(ip)))
|
||||
softdep_setup_blkmapdep(bp, fs, bprev);
|
||||
|
||||
bdwrite(bp);
|
||||
return (bprev);
|
||||
|
@ -1015,8 +1012,6 @@ ffs_alloccg(struct inode *ip, u_int cg, daddr_t bpref, int size)
|
|||
cgp->cg_frsum[allocsiz - frags]++;
|
||||
|
||||
blkno = cgbase(fs, cg) + bno;
|
||||
if (DOINGSOFTDEP(ITOV(ip)))
|
||||
softdep_setup_blkmapdep(bp, fs, blkno);
|
||||
bdwrite(bp);
|
||||
return (blkno);
|
||||
}
|
||||
|
@ -1082,9 +1077,6 @@ gotit:
|
|||
fs->fs_fmod = 1;
|
||||
blkno = cgbase(fs, cgp->cg_cgx) + bno;
|
||||
|
||||
if (DOINGSOFTDEP(ITOV(ip)))
|
||||
softdep_setup_blkmapdep(bp, fs, blkno);
|
||||
|
||||
return (blkno);
|
||||
}
|
||||
|
||||
|
@ -1220,9 +1212,6 @@ gotit:
|
|||
}
|
||||
#endif /* FFS2 */
|
||||
|
||||
if (DOINGSOFTDEP(ITOV(ip)))
|
||||
softdep_setup_inomapdep(bp, ip, cg * fs->fs_ipg + ipref);
|
||||
|
||||
setbit(cg_inosused(cgp), ipref);
|
||||
|
||||
/* Update the counters we keep on free inodes */
|
||||
|
@ -1363,13 +1352,6 @@ ffs_blkfree(struct inode *ip, daddr_t bno, long size)
|
|||
int
|
||||
ffs_inode_free(struct inode *pip, ufsino_t ino, mode_t mode)
|
||||
{
|
||||
struct vnode *pvp = ITOV(pip);
|
||||
|
||||
if (DOINGSOFTDEP(pvp)) {
|
||||
softdep_freefile(pvp, ino, mode);
|
||||
return (0);
|
||||
}
|
||||
|
||||
return (ffs_freefile(pip, ino, mode));
|
||||
}
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_balloc.c,v 1.45 2019/07/19 00:24:31 cheloha Exp $ */
|
||||
/* $OpenBSD: ffs_balloc.c,v 1.46 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_balloc.c,v 1.3 1996/02/09 22:22:21 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -107,10 +107,6 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
osize, (int)fs->fs_bsize, cred, bpp, &newb);
|
||||
if (error)
|
||||
return (error);
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, nb, newb,
|
||||
ip->i_ffs1_db[nb], fs->fs_bsize, osize,
|
||||
bpp ? *bpp : NULL);
|
||||
|
||||
ip->i_ffs1_size = lblktosize(fs, nb + 1);
|
||||
uvm_vnp_setsize(vp, ip->i_ffs1_size);
|
||||
|
@ -179,10 +175,6 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
osize, nsize, cred, bpp, &newb);
|
||||
if (error)
|
||||
return (error);
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, lbn,
|
||||
newb, nb, nsize, osize,
|
||||
bpp ? *bpp : NULL);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
|
@ -207,9 +199,6 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
if (flags & B_CLRBUF)
|
||||
clrbuf(*bpp);
|
||||
}
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, lbn, newb, 0,
|
||||
nsize, 0, bpp ? *bpp : NULL);
|
||||
}
|
||||
ip->i_ffs1_db[lbn] = newb;
|
||||
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
||||
|
@ -247,18 +236,12 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
bp->b_blkno = fsbtodb(fs, nb);
|
||||
clrbuf(bp);
|
||||
|
||||
if (DOINGSOFTDEP(vp)) {
|
||||
softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
|
||||
newb, 0, fs->fs_bsize, 0, bp);
|
||||
bdwrite(bp);
|
||||
} else {
|
||||
/*
|
||||
* Write synchronously so that indirect blocks
|
||||
* never point at garbage.
|
||||
*/
|
||||
if ((error = bwrite(bp)) != 0)
|
||||
goto fail;
|
||||
}
|
||||
/*
|
||||
* Write synchronously so that indirect blocks
|
||||
* never point at garbage.
|
||||
*/
|
||||
if ((error = bwrite(bp)) != 0)
|
||||
goto fail;
|
||||
allocib = &ip->i_ffs1_ib[indirs[0].in_off];
|
||||
*allocib = nb;
|
||||
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
||||
|
@ -296,19 +279,13 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
nbp->b_blkno = fsbtodb(fs, nb);
|
||||
clrbuf(nbp);
|
||||
|
||||
if (DOINGSOFTDEP(vp)) {
|
||||
softdep_setup_allocindir_meta(nbp, ip, bp,
|
||||
indirs[i - 1].in_off, nb);
|
||||
bdwrite(nbp);
|
||||
} else {
|
||||
/*
|
||||
* Write synchronously so that indirect blocks
|
||||
* never point at garbage.
|
||||
*/
|
||||
if ((error = bwrite(nbp)) != 0) {
|
||||
brelse(bp);
|
||||
goto fail;
|
||||
}
|
||||
/*
|
||||
* Write synchronously so that indirect blocks
|
||||
* never point at garbage.
|
||||
*/
|
||||
if ((error = bwrite(nbp)) != 0) {
|
||||
brelse(bp);
|
||||
goto fail;
|
||||
}
|
||||
bap[indirs[i - 1].in_off] = nb;
|
||||
if (allocib == NULL && unwindidx < 0)
|
||||
|
@ -343,9 +320,6 @@ ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
|
|||
clrbuf(nbp);
|
||||
*bpp = nbp;
|
||||
}
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocindir_page(ip, lbn, bp,
|
||||
indirs[i].in_off, nb, 0, bpp ? *bpp : NULL);
|
||||
bap[indirs[i].in_off] = nb;
|
||||
/*
|
||||
* If required, write synchronously, otherwise use
|
||||
|
@ -473,11 +447,6 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
if (error)
|
||||
return (error);
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, nb, newb,
|
||||
ip->i_ffs2_db[nb], fs->fs_bsize, osize,
|
||||
bpp ? *bpp : NULL);
|
||||
|
||||
ip->i_ffs2_size = lblktosize(fs, nb + 1);
|
||||
uvm_vnp_setsize(vp, ip->i_ffs2_size);
|
||||
ip->i_ffs2_db[nb] = newb;
|
||||
|
@ -550,11 +519,6 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
bpp, &newb);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, lbn,
|
||||
newb, nb, nsize, osize,
|
||||
bpp ? *bpp : NULL);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
|
@ -580,10 +544,6 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
clrbuf(bp);
|
||||
*bpp = bp;
|
||||
}
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocdirect(ip, lbn, newb, 0,
|
||||
nsize, 0, bpp ? *bpp : NULL);
|
||||
}
|
||||
|
||||
ip->i_ffs2_db[lbn] = newb;
|
||||
|
@ -626,19 +586,13 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
bp->b_blkno = fsbtodb(fs, nb);
|
||||
clrbuf(bp);
|
||||
|
||||
if (DOINGSOFTDEP(vp)) {
|
||||
softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
|
||||
newb, 0, fs->fs_bsize, 0, bp);
|
||||
bdwrite(bp);
|
||||
} else {
|
||||
/*
|
||||
* Write synchronously so that indirect blocks never
|
||||
* point at garbage.
|
||||
*/
|
||||
error = bwrite(bp);
|
||||
if (error)
|
||||
goto fail;
|
||||
}
|
||||
/*
|
||||
* Write synchronously so that indirect blocks never
|
||||
* point at garbage.
|
||||
*/
|
||||
error = bwrite(bp);
|
||||
if (error)
|
||||
goto fail;
|
||||
|
||||
unwindidx = 0;
|
||||
allocib = &ip->i_ffs2_ib[indirs[0].in_off];
|
||||
|
@ -685,20 +639,14 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
nbp->b_blkno = fsbtodb(fs, nb);
|
||||
clrbuf(nbp);
|
||||
|
||||
if (DOINGSOFTDEP(vp)) {
|
||||
softdep_setup_allocindir_meta(nbp, ip, bp,
|
||||
indirs[i - 1].in_off, nb);
|
||||
bdwrite(nbp);
|
||||
} else {
|
||||
/*
|
||||
* Write synchronously so that indirect blocks never
|
||||
* point at garbage.
|
||||
*/
|
||||
error = bwrite(nbp);
|
||||
if (error) {
|
||||
brelse(bp);
|
||||
goto fail;
|
||||
}
|
||||
/*
|
||||
* Write synchronously so that indirect blocks never
|
||||
* point at garbage.
|
||||
*/
|
||||
error = bwrite(nbp);
|
||||
if (error) {
|
||||
brelse(bp);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (unwindidx < 0)
|
||||
|
@ -740,10 +688,6 @@ ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
|
|||
*bpp = nbp;
|
||||
}
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_setup_allocindir_page(ip, lbn, bp,
|
||||
indirs[num].in_off, nb, 0, bpp ? *bpp : NULL);
|
||||
|
||||
bap[indirs[num].in_off] = nb;
|
||||
|
||||
if (allocib == NULL && unwindidx < 0)
|
||||
|
@ -830,11 +774,6 @@ fail:
|
|||
}
|
||||
}
|
||||
|
||||
if (DOINGSOFTDEP(vp) && unwindidx == 0) {
|
||||
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
||||
ffs_update(ip, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Now that any dependencies that we created have been
|
||||
* resolved, we can undo the partial allocation.
|
||||
|
@ -842,8 +781,6 @@ fail:
|
|||
if (unwindidx == 0) {
|
||||
*allocib = 0;
|
||||
ip->i_flag |= IN_CHANGE | IN_UPDATE;
|
||||
if (DOINGSOFTDEP(vp))
|
||||
ffs_update(ip, 1);
|
||||
} else {
|
||||
r = bread(vp, indirs[unwindidx].in_lbn,
|
||||
(int)fs->fs_bsize, &bp);
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_extern.h,v 1.45 2020/01/20 23:21:56 claudio Exp $ */
|
||||
/* $OpenBSD: ffs_extern.h,v 1.46 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_extern.h,v 1.4 1996/02/09 22:22:22 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -36,7 +36,6 @@
|
|||
#define FFS_CLUSTERWRITE 2 /* cluster writing enabled */
|
||||
#define FFS_REALLOCBLKS 3 /* block reallocation enabled */
|
||||
#define FFS_ASYNCFREE 4 /* asynchronous block freeing enabled */
|
||||
#define FFS_MAX_SOFTDEPS 5 /* maximum structs before slowdown */
|
||||
#define FFS_SD_TICKDELAY 6 /* ticks to pause during slowdown */
|
||||
#define FFS_SD_WORKLIST_PUSH 7 /* # of worklist cleanups */
|
||||
#define FFS_SD_BLK_LIMIT_PUSH 8 /* # of times block limit neared */
|
||||
|
@ -59,7 +58,6 @@
|
|||
{ 0, 0 }, \
|
||||
{ 0, 0 }, \
|
||||
{ 0, 0 }, \
|
||||
{ "max_softdeps", CTLTYPE_INT }, \
|
||||
{ "sd_tickdelay", CTLTYPE_INT }, \
|
||||
{ "sd_worklist_push", CTLTYPE_INT }, \
|
||||
{ "sd_blk_limit_push", CTLTYPE_INT }, \
|
||||
|
@ -167,28 +165,6 @@ int ffsfifo_reclaim(void *);
|
|||
struct vop_vfree_args;
|
||||
struct vop_fsync_args;
|
||||
|
||||
void softdep_initialize(void);
|
||||
int softdep_process_worklist(struct mount *);
|
||||
int softdep_mount(struct vnode *, struct mount *, struct fs *,
|
||||
struct ucred *);
|
||||
int softdep_flushworklist(struct mount *, int *, struct proc *);
|
||||
int softdep_flushfiles(struct mount *, int, struct proc *);
|
||||
void softdep_update_inodeblock(struct inode *, struct buf *, int);
|
||||
void softdep_load_inodeblock(struct inode *);
|
||||
void softdep_freefile(struct vnode *, ufsino_t, mode_t);
|
||||
void softdep_setup_freeblocks(struct inode *, off_t);
|
||||
void softdep_setup_inomapdep(struct buf *, struct inode *, ufsino_t);
|
||||
void softdep_setup_blkmapdep(struct buf *, struct fs *, daddr_t);
|
||||
void softdep_setup_allocdirect(struct inode *, daddr_t, daddr_t,
|
||||
daddr_t, long, long, struct buf *);
|
||||
void softdep_setup_allocindir_meta(struct buf *, struct inode *,
|
||||
struct buf *, int, daddr_t);
|
||||
void softdep_setup_allocindir_page(struct inode *, daddr_t,
|
||||
struct buf *, int, daddr_t, daddr_t, struct buf *);
|
||||
void softdep_fsync_mountdev(struct vnode *, int);
|
||||
int softdep_sync_metadata(struct vop_fsync_args *);
|
||||
int softdep_fsync(struct vnode *);
|
||||
|
||||
extern struct pool ffs_ino_pool; /* memory pool for inodes */
|
||||
extern struct pool ffs_dinode1_pool; /* memory pool for UFS1 dinodes */
|
||||
#ifdef FFS2
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_inode.c,v 1.82 2024/01/09 03:15:59 guenther Exp $ */
|
||||
/* $OpenBSD: ffs_inode.c,v 1.83 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_inode.c,v 1.10 1996/05/11 18:27:19 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -95,9 +95,7 @@ ffs_update(struct inode *ip, int waitfor)
|
|||
return (error);
|
||||
}
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_update_inodeblock(ip, bp, waitfor);
|
||||
else if (ip->i_effnlink != DIP(ip, nlink))
|
||||
if (ip->i_effnlink != DIP(ip, nlink))
|
||||
panic("ffs_update: bad link cnt");
|
||||
|
||||
#ifdef FFS2
|
||||
|
@ -174,30 +172,6 @@ ffs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
|
|||
oip->i_ci.ci_lasta = oip->i_ci.ci_clen
|
||||
= oip->i_ci.ci_cstart = oip->i_ci.ci_lastw = 0;
|
||||
|
||||
if (DOINGSOFTDEP(ovp)) {
|
||||
if (length > 0 || softdep_slowdown(ovp)) {
|
||||
/*
|
||||
* If a file is only partially truncated, then
|
||||
* we have to clean up the data structures
|
||||
* describing the allocation past the truncation
|
||||
* point. Finding and deallocating those structures
|
||||
* is a lot of work. Since partial truncation occurs
|
||||
* rarely, we solve the problem by syncing the file
|
||||
* so that it will have no data structures left.
|
||||
*/
|
||||
if ((error = VOP_FSYNC(ovp, cred, MNT_WAIT,
|
||||
curproc)) != 0)
|
||||
return (error);
|
||||
} else {
|
||||
(void)ufs_quota_free_blocks(oip, DIP(oip, blocks),
|
||||
NOCRED);
|
||||
softdep_setup_freeblocks(oip, length);
|
||||
vinvalbuf(ovp, 0, cred, curproc, 0, INFSLP);
|
||||
oip->i_flag |= IN_CHANGE | IN_UPDATE;
|
||||
return (UFS_UPDATE(oip, 0));
|
||||
}
|
||||
}
|
||||
|
||||
osize = DIP(oip, size);
|
||||
/*
|
||||
* Lengthen the size of the file. We must ensure that the
|
||||
|
@ -244,18 +218,6 @@ ffs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
|
|||
cred, aflags, &bp);
|
||||
if (error)
|
||||
return (error);
|
||||
/*
|
||||
* When we are doing soft updates and the UFS_BALLOC
|
||||
* above fills in a direct block hole with a full sized
|
||||
* block that will be truncated down to a fragment below,
|
||||
* we must flush out the block dependency with an FSYNC
|
||||
* so that we do not get a soft updates inconsistency
|
||||
* when we create the fragment below.
|
||||
*/
|
||||
if (DOINGSOFTDEP(ovp) && lbn < NDADDR &&
|
||||
fragroundup(fs, blkoff(fs, length)) < fs->fs_bsize &&
|
||||
(error = VOP_FSYNC(ovp, cred, MNT_WAIT, curproc)) != 0)
|
||||
return (error);
|
||||
DIP_ASSIGN(oip, size, length);
|
||||
size = blksize(fs, oip, lbn);
|
||||
(void) uvm_vnp_uncache(ovp);
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -1,193 +0,0 @@
|
|||
/* $OpenBSD: ffs_softdep_stub.c,v 1.18 2013/06/11 16:42:18 deraadt Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright 1998 Marshall Kirk McKusick. All Rights Reserved.
|
||||
*
|
||||
* The soft updates code is derived from the appendix of a University
|
||||
* of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
|
||||
* "Soft Updates: A Solution to the Metadata Update Problem in File
|
||||
* Systems", CSE-TR-254-95, August 1995).
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. None of the names of McKusick, Ganger, or the University of Michigan
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* from: @(#)ffs_softdep_stub.c 9.1 (McKusick) 7/10/97
|
||||
* $FreeBSD: src/sys/ufs/ffs/ffs_softdep_stub.c,v 1.14 2000/08/09 00:41:54 tegge Exp $
|
||||
*/
|
||||
|
||||
#ifndef FFS_SOFTUPDATES
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/systm.h>
|
||||
#include <ufs/ufs/quota.h>
|
||||
#include <ufs/ufs/inode.h>
|
||||
#include <ufs/ffs/ffs_extern.h>
|
||||
#include <ufs/ufs/ufs_extern.h>
|
||||
|
||||
int
|
||||
softdep_flushfiles(struct mount *oldmnt, int flags, struct proc *p)
|
||||
{
|
||||
panic("softdep_flushfiles called");
|
||||
}
|
||||
|
||||
int
|
||||
softdep_mount(struct vnode *devvp, struct mount *mp, struct fs *fs,
|
||||
struct ucred *cred)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
softdep_initialize(void)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
#ifndef __OPTIMIZE__
|
||||
|
||||
void
|
||||
softdep_setup_inomapdep(struct buf *bp, struct inode *ip, ufsino_t newinum)
|
||||
{
|
||||
panic("softdep_setup_inomapdep called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_blkmapdep(struct buf *bp, struct fs *fs, daddr_t newblkno)
|
||||
{
|
||||
panic("softdep_setup_blkmapdep called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_allocdirect(struct inode *ip, daddr_t lbn, daddr_t newblkno,
|
||||
daddr_t oldblkno, long newsize, long oldsize, struct buf *bp)
|
||||
{
|
||||
panic("softdep_setup_allocdirect called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_allocindir_page(struct inode *ip, daddr_t lbn, struct buf *bp,
|
||||
int ptrno, daddr_t newblkno, daddr_t oldblkno, struct buf *nbp)
|
||||
{
|
||||
panic("softdep_setup_allocindir_page called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_allocindir_meta(struct buf *nbp, struct inode *ip,
|
||||
struct buf *bp, int ptrno, daddr_t newblkno)
|
||||
{
|
||||
panic("softdep_setup_allocindir_meta called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_freeblocks(struct inode *ip, off_t length)
|
||||
{
|
||||
panic("softdep_setup_freeblocks called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_freefile(struct vnode *pvp, ufsino_t ino, mode_t mode)
|
||||
{
|
||||
panic("softdep_freefile called");
|
||||
}
|
||||
|
||||
int
|
||||
softdep_setup_directory_add(struct buf *bp, struct inode *dp, off_t diroffset,
|
||||
long newinum, struct buf *newdirbp, int isnewblk)
|
||||
{
|
||||
panic("softdep_setup_directory_add called");
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
softdep_change_directoryentry_offset(struct inode *dp, caddr_t base,
|
||||
caddr_t oldloc, caddr_t newloc, int entrysize)
|
||||
{
|
||||
panic("softdep_change_directoryentry_offset called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_remove(struct buf *bp, struct inode *dp, struct inode *ip,
|
||||
int isrmdir)
|
||||
{
|
||||
panic("softdep_setup_remove called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_setup_directory_change(struct buf *bp, struct inode *dp,
|
||||
struct inode *ip, long newinum, int isrmdir)
|
||||
{
|
||||
panic("softdep_setup_directory_change called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_change_linkcnt(struct inode *ip, int nodelay)
|
||||
{
|
||||
panic("softdep_change_linkcnt called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_load_inodeblock(struct inode *ip)
|
||||
{
|
||||
panic("softdep_load_inodeblock called");
|
||||
}
|
||||
|
||||
void
|
||||
softdep_update_inodeblock(struct inode *ip, struct buf *bp, int waitfor)
|
||||
{
|
||||
panic("softdep_update_inodeblock called");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void
|
||||
softdep_fsync_mountdev(struct vnode *vp, int waitfor)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int
|
||||
softdep_flushworklist(struct mount *oldmnt, int *countp, struct proc *p)
|
||||
{
|
||||
*countp = 0;
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
softdep_sync_metadata(struct vop_fsync_args *ap)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifndef __OPTIMIZE__
|
||||
|
||||
int
|
||||
softdep_slowdown(struct vnode *vp)
|
||||
{
|
||||
panic("softdep_slowdown called");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* !FFS_SOFTUPDATES */
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_vfsops.c,v 1.197 2024/01/19 18:58:17 deraadt Exp $ */
|
||||
/* $OpenBSD: ffs_vfsops.c,v 1.198 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_vfsops.c,v 1.19 1996/02/09 22:22:26 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -213,20 +213,6 @@ ffs_mount(struct mount *mp, const char *path, void *data,
|
|||
int error = 0, flags;
|
||||
int ronly;
|
||||
|
||||
/* Ask not for whom the bell tolls */
|
||||
if (mp->mnt_flag & MNT_SOFTDEP) {
|
||||
mp->mnt_flag &= ~MNT_SOFTDEP;
|
||||
}
|
||||
|
||||
/*
|
||||
* Soft updates is incompatible with "async",
|
||||
* so if we are doing softupdates stop the user
|
||||
* from setting the async flag.
|
||||
*/
|
||||
if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
|
||||
(MNT_SOFTDEP | MNT_ASYNC)) {
|
||||
return (EINVAL);
|
||||
}
|
||||
/*
|
||||
* If updating, check whether changing from read-only to
|
||||
* read/write; if there is no device name, that's all we do.
|
||||
|
@ -238,16 +224,6 @@ ffs_mount(struct mount *mp, const char *path, void *data,
|
|||
error = 0;
|
||||
ronly = fs->fs_ronly;
|
||||
|
||||
/*
|
||||
* Soft updates won't be set if read/write,
|
||||
* so "async" will be illegal.
|
||||
*/
|
||||
if (ronly == 0 && (mp->mnt_flag & MNT_ASYNC) &&
|
||||
(fs->fs_flags & FS_DOSOFTDEP)) {
|
||||
error = EINVAL;
|
||||
goto error_1;
|
||||
}
|
||||
|
||||
if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
|
||||
/* Flush any dirty data */
|
||||
VFS_SYNC(mp, MNT_WAIT, 0, p->p_ucred, p);
|
||||
|
@ -260,46 +236,11 @@ ffs_mount(struct mount *mp, const char *path, void *data,
|
|||
flags |= IGNORECLEAN;
|
||||
if (mp->mnt_flag & MNT_FORCE)
|
||||
flags |= FORCECLOSE;
|
||||
if (fs->fs_flags & FS_DOSOFTDEP) {
|
||||
error = softdep_flushfiles(mp, flags, p);
|
||||
mp->mnt_flag &= ~MNT_SOFTDEP;
|
||||
} else
|
||||
error = ffs_flushfiles(mp, flags, p);
|
||||
error = ffs_flushfiles(mp, flags, p);
|
||||
mp->mnt_flag |= MNT_RDONLY;
|
||||
ronly = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Flush soft dependencies if disabling it via an update
|
||||
* mount. This may leave some items to be processed,
|
||||
* so don't do this yet XXX.
|
||||
*/
|
||||
if ((fs->fs_flags & FS_DOSOFTDEP) &&
|
||||
!(mp->mnt_flag & MNT_SOFTDEP) &&
|
||||
!(mp->mnt_flag & MNT_RDONLY) && fs->fs_ronly == 0) {
|
||||
#if 0
|
||||
flags = WRITECLOSE;
|
||||
if (mp->mnt_flag & MNT_FORCE)
|
||||
flags |= FORCECLOSE;
|
||||
error = softdep_flushfiles(mp, flags, p);
|
||||
#endif
|
||||
}
|
||||
/*
|
||||
* When upgrading to a softdep mount, we must first flush
|
||||
* all vnodes. (not done yet -- see above)
|
||||
*/
|
||||
if (!(fs->fs_flags & FS_DOSOFTDEP) &&
|
||||
(mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
|
||||
#if 0
|
||||
flags = WRITECLOSE;
|
||||
if (mp->mnt_flag & MNT_FORCE)
|
||||
flags |= FORCECLOSE;
|
||||
error = ffs_flushfiles(mp, flags, p);
|
||||
#else
|
||||
mp->mnt_flag &= ~MNT_SOFTDEP;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (!error && (mp->mnt_flag & MNT_RELOAD))
|
||||
error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p);
|
||||
if (error)
|
||||
|
@ -307,19 +248,6 @@ ffs_mount(struct mount *mp, const char *path, void *data,
|
|||
|
||||
if (ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
|
||||
if (fs->fs_clean == 0) {
|
||||
#if 0
|
||||
/*
|
||||
* It is safe to mount an unclean file system
|
||||
* if it was previously mounted with softdep
|
||||
* but we may lose space and must
|
||||
* sometimes run fsck manually.
|
||||
*/
|
||||
if (fs->fs_flags & FS_DOSOFTDEP)
|
||||
printf(
|
||||
"WARNING: %s was not properly unmounted\n",
|
||||
fs->fs_fsmnt);
|
||||
else
|
||||
#endif
|
||||
if (mp->mnt_flag & MNT_FORCE) {
|
||||
printf(
|
||||
"WARNING: %s was not properly unmounted\n",
|
||||
|
@ -333,12 +261,6 @@ ffs_mount(struct mount *mp, const char *path, void *data,
|
|||
}
|
||||
}
|
||||
|
||||
if ((fs->fs_flags & FS_DOSOFTDEP)) {
|
||||
error = softdep_mount(devvp, mp, fs,
|
||||
p->p_ucred);
|
||||
if (error)
|
||||
goto error_1;
|
||||
}
|
||||
fs->fs_contigdirs = malloc((u_long)fs->fs_ncg,
|
||||
M_UFSMNT, M_WAITOK|M_ZERO);
|
||||
|
||||
|
@ -454,9 +376,6 @@ success:
|
|||
if (ronly)
|
||||
free(fs->fs_contigdirs, M_UFSMNT, fs->fs_ncg);
|
||||
}
|
||||
if (!ronly) {
|
||||
fs->fs_flags &= ~FS_DOSOFTDEP;
|
||||
}
|
||||
ffs_sbupdate(ump, MNT_WAIT);
|
||||
#if 0
|
||||
if (ronly) {
|
||||
|
@ -627,8 +546,6 @@ ffs_reload(struct mount *mountp, struct ucred *cred, struct proc *p)
|
|||
space += size;
|
||||
brelse(bp);
|
||||
}
|
||||
if ((fs->fs_flags & FS_DOSOFTDEP))
|
||||
(void) softdep_mount(devvp, mountp, fs, cred);
|
||||
/*
|
||||
* We no longer know anything about clusters per cylinder group.
|
||||
*/
|
||||
|
@ -767,19 +684,6 @@ ffs_mountfs(struct vnode *devvp, struct mount *mp, struct proc *p)
|
|||
fs->fs_fmod = 0;
|
||||
fs->fs_flags &= ~FS_UNCLEAN;
|
||||
if (fs->fs_clean == 0) {
|
||||
#if 0
|
||||
/*
|
||||
* It is safe to mount an unclean file system
|
||||
* if it was previously mounted with softdep
|
||||
* but we may lose space and must
|
||||
* sometimes run fsck manually.
|
||||
*/
|
||||
if (fs->fs_flags & FS_DOSOFTDEP)
|
||||
printf(
|
||||
"WARNING: %s was not properly unmounted\n",
|
||||
fs->fs_fsmnt);
|
||||
else
|
||||
#endif
|
||||
if (ronly || (mp->mnt_flag & MNT_FORCE)) {
|
||||
printf(
|
||||
"WARNING: %s was not properly unmounted\n",
|
||||
|
@ -908,15 +812,8 @@ ffs_mountfs(struct vnode *devvp, struct mount *mp, struct proc *p)
|
|||
if (fs->fs_maxfilesize > maxfilesize) /* XXX */
|
||||
fs->fs_maxfilesize = maxfilesize; /* XXX */
|
||||
if (ronly == 0) {
|
||||
if ((fs->fs_flags & FS_DOSOFTDEP) &&
|
||||
(error = softdep_mount(devvp, mp, fs, cred)) != 0) {
|
||||
free(fs->fs_csp, M_UFSMNT, 0);
|
||||
free(fs->fs_contigdirs, M_UFSMNT, fs->fs_ncg);
|
||||
goto out;
|
||||
}
|
||||
fs->fs_fmod = 1;
|
||||
fs->fs_clean = 0;
|
||||
fs->fs_flags &= ~FS_DOSOFTDEP;
|
||||
error = ffs_sbupdate(ump, MNT_WAIT);
|
||||
if (error == EROFS)
|
||||
goto out;
|
||||
|
@ -1028,10 +925,7 @@ ffs_unmount(struct mount *mp, int mntflags, struct proc *p)
|
|||
|
||||
ump = VFSTOUFS(mp);
|
||||
fs = ump->um_fs;
|
||||
if (mp->mnt_flag & MNT_SOFTDEP)
|
||||
error = softdep_flushfiles(mp, flags, p);
|
||||
else
|
||||
error = ffs_flushfiles(mp, flags, p);
|
||||
error = ffs_flushfiles(mp, flags, p);
|
||||
if (error != 0)
|
||||
return (error);
|
||||
|
||||
|
@ -1206,7 +1100,7 @@ ffs_sync(struct mount *mp, int waitfor, int stall, struct ucred *cred, struct pr
|
|||
{
|
||||
struct ufsmount *ump = VFSTOUFS(mp);
|
||||
struct fs *fs;
|
||||
int error, allerror = 0, count, clean, fmod;
|
||||
int error, allerror = 0, clean, fmod;
|
||||
struct ffs_sync_args fsa;
|
||||
|
||||
fs = ump->um_fs;
|
||||
|
@ -1219,7 +1113,7 @@ ffs_sync(struct mount *mp, int waitfor, int stall, struct ucred *cred, struct pr
|
|||
printf("fs = %s\n", fs->fs_fsmnt);
|
||||
panic("update: rofs mod");
|
||||
}
|
||||
loop:
|
||||
|
||||
/*
|
||||
* Write back each (modified) inode.
|
||||
*/
|
||||
|
@ -1241,13 +1135,6 @@ ffs_sync(struct mount *mp, int waitfor, int stall, struct ucred *cred, struct pr
|
|||
/*
|
||||
* Force stale file system control information to be flushed.
|
||||
*/
|
||||
if ((ump->um_mountp->mnt_flag & MNT_SOFTDEP) && waitfor == MNT_WAIT) {
|
||||
if ((error = softdep_flushworklist(ump->um_mountp, &count, p)))
|
||||
allerror = error;
|
||||
/* Flushed work items may create new vnodes to clean */
|
||||
if (count)
|
||||
goto loop;
|
||||
}
|
||||
if (waitfor != MNT_LAZY) {
|
||||
vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
|
||||
if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0)
|
||||
|
@ -1387,10 +1274,7 @@ retry:
|
|||
|
||||
brelse(bp);
|
||||
|
||||
if (DOINGSOFTDEP(vp))
|
||||
softdep_load_inodeblock(ip);
|
||||
else
|
||||
ip->i_effnlink = DIP(ip, nlink);
|
||||
ip->i_effnlink = DIP(ip, nlink);
|
||||
|
||||
/*
|
||||
* Initialize the vnode from the inode, check for aliases.
|
||||
|
@ -1556,32 +1440,10 @@ ffs_init(struct vfsconf *vfsp)
|
|||
PR_WAITOK, "dino2pl", NULL);
|
||||
#endif
|
||||
|
||||
softdep_initialize();
|
||||
|
||||
return (ufs_init(vfsp));
|
||||
}
|
||||
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
extern int max_softdeps, tickdelay, stat_worklist_push;
|
||||
extern int stat_blk_limit_push, stat_ino_limit_push, stat_blk_limit_hit;
|
||||
extern int stat_ino_limit_hit, stat_sync_limit_hit, stat_indir_blk_ptrs;
|
||||
extern int stat_inode_bitmap, stat_direct_blk_ptrs, stat_dir_entry;
|
||||
#endif
|
||||
const struct sysctl_bounded_args ffs_vars[] = {
|
||||
#ifdef FFS_SOFTUPDATES
|
||||
{ FFS_MAX_SOFTDEPS, &max_softdeps, 0, INT_MAX },
|
||||
{ FFS_SD_TICKDELAY, &tickdelay, 2, INT_MAX },
|
||||
{ FFS_SD_WORKLIST_PUSH, &stat_worklist_push, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_BLK_LIMIT_PUSH, &stat_blk_limit_push, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_INO_LIMIT_PUSH, &stat_ino_limit_push, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_BLK_LIMIT_HIT, &stat_blk_limit_hit, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_INO_LIMIT_HIT, &stat_ino_limit_hit, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_SYNC_LIMIT_HIT, &stat_sync_limit_hit, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_INDIR_BLK_PTRS, &stat_indir_blk_ptrs, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_INODE_BITMAP, &stat_inode_bitmap, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_DIRECT_BLK_PTRS, &stat_direct_blk_ptrs, SYSCTL_INT_READONLY },
|
||||
{ FFS_SD_DIR_ENTRY, &stat_dir_entry, SYSCTL_INT_READONLY },
|
||||
#endif
|
||||
#ifdef UFS_DIRHASH
|
||||
{ FFS_DIRHASH_DIRSIZE, &ufs_mindirhashsize, 0, INT_MAX },
|
||||
{ FFS_DIRHASH_MAXMEM, &ufs_dirhashmaxmem, 0, INT_MAX },
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ffs_vnops.c,v 1.101 2024/01/09 03:16:00 guenther Exp $ */
|
||||
/* $OpenBSD: ffs_vnops.c,v 1.102 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -420,11 +420,6 @@ ffs_fsync(void *v)
|
|||
struct buf *bp, *nbp;
|
||||
int s, error, passes, skipmeta;
|
||||
|
||||
if (vp->v_type == VBLK &&
|
||||
vp->v_specmountpoint != NULL &&
|
||||
(vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
|
||||
softdep_fsync_mountdev(vp, ap->a_waitfor);
|
||||
|
||||
/*
|
||||
* Flush all dirty buffers associated with a vnode.
|
||||
*/
|
||||
|
@ -452,13 +447,6 @@ loop:
|
|||
panic("ffs_fsync: not dirty");
|
||||
if (skipmeta && bp->b_lblkno < 0)
|
||||
continue;
|
||||
if (ap->a_waitfor != MNT_WAIT &&
|
||||
LIST_FIRST(&bp->b_dep) != NULL &&
|
||||
(bp->b_flags & B_DEFERRED) == 0 &&
|
||||
buf_countdeps(bp, 0, 1)) {
|
||||
bp->b_flags |= B_DEFERRED;
|
||||
continue;
|
||||
}
|
||||
|
||||
bremfree(bp);
|
||||
buf_acquire(bp);
|
||||
|
@ -492,8 +480,7 @@ loop:
|
|||
* with the vnode has been written.
|
||||
*/
|
||||
splx(s);
|
||||
if ((error = softdep_sync_metadata(ap)) != 0)
|
||||
return (error);
|
||||
/* XXX softdep was here. reconsider this locking dance */
|
||||
s = splbio();
|
||||
if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
|
||||
/*
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: fs.h,v 1.44 2022/01/11 03:13:59 jsg Exp $ */
|
||||
/* $OpenBSD: fs.h,v 1.45 2024/02/03 18:51:58 beck Exp $ */
|
||||
/* $NetBSD: fs.h,v 1.6 1995/04/12 21:21:02 mycroft Exp $ */
|
||||
|
||||
/*
|
||||
|
@ -328,7 +328,6 @@ struct fs {
|
|||
* Filesystem flags.
|
||||
*/
|
||||
#define FS_UNCLEAN 0x01 /* filesystem not clean at mount */
|
||||
#define FS_DOSOFTDEP 0x02 /* filesystem using soft dependencies */
|
||||
/*
|
||||
* The following flag is used to detect a FFS1 file system that had its flags
|
||||
* moved to the new (FFS2) location for compatibility.
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue