crypto/krb5/src/lib/crypto/builtin/enc_provider/rc4.c

45

unsigned int sx, sy;

crypto/krb5/src/lib/crypto/builtin/enc_provider/rc4.c

50

sx = state[x];

crypto/krb5/src/lib/crypto/builtin/enc_provider/rc4.c

51

y = (sx + ctx->y) & 0xff;

crypto/krb5/src/lib/crypto/builtin/enc_provider/rc4.c

55

state[y] = sx;

crypto/krb5/src/lib/crypto/builtin/enc_provider/rc4.c

57

return state[(sx + sy) & 0xff];

crypto/openssl/crypto/x509/v3_sxnet.c

102

SXNET *sx = NULL;

crypto/openssl/crypto/x509/v3_sxnet.c

106

if (!SXNET_add_id_asc(&sx, cnf->name, cnf->value, -1)) {

crypto/openssl/crypto/x509/v3_sxnet.c

107

SXNET_free(sx);

crypto/openssl/crypto/x509/v3_sxnet.c

111

return sx;

crypto/openssl/crypto/x509/v3_sxnet.c

163

SXNET *sx = NULL;

crypto/openssl/crypto/x509/v3_sxnet.c

177

if ((sx = SXNET_new()) == NULL) {

crypto/openssl/crypto/x509/v3_sxnet.c

181

if (!ASN1_INTEGER_set(sx->version, 0)) {

crypto/openssl/crypto/x509/v3_sxnet.c

186

sx = *psx;

crypto/openssl/crypto/x509/v3_sxnet.c

187

if (SXNET_get_id_INTEGER(sx, zone)) {

crypto/openssl/crypto/x509/v3_sxnet.c

190

SXNET_free(sx);

crypto/openssl/crypto/x509/v3_sxnet.c

203

if (!sk_SXNETID_push(sx->ids, id)) {

crypto/openssl/crypto/x509/v3_sxnet.c

209

*psx = sx;

crypto/openssl/crypto/x509/v3_sxnet.c

215

SXNET_free(sx);

crypto/openssl/crypto/x509/v3_sxnet.c

219

ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone)

crypto/openssl/crypto/x509/v3_sxnet.c

22

static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out,

crypto/openssl/crypto/x509/v3_sxnet.c

228

oct = SXNET_get_id_INTEGER(sx, izone);

crypto/openssl/crypto/x509/v3_sxnet.c

233

ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)

crypto/openssl/crypto/x509/v3_sxnet.c

244

oct = SXNET_get_id_INTEGER(sx, izone);

crypto/openssl/crypto/x509/v3_sxnet.c

249

ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)

crypto/openssl/crypto/x509/v3_sxnet.c

253

for (i = 0; i < sk_SXNETID_num(sx->ids); i++) {

crypto/openssl/crypto/x509/v3_sxnet.c

254

id = sk_SXNETID_value(sx->ids, i);

crypto/openssl/crypto/x509/v3_sxnet.c

57

static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out,

crypto/openssl/crypto/x509/v3_sxnet.c

69

if (!ASN1_INTEGER_get_int64(&v, sx->version)

crypto/openssl/crypto/x509/v3_sxnet.c

78

for (i = 0; i < sk_SXNETID_num(sx->ids); i++) {

crypto/openssl/crypto/x509/v3_sxnet.c

79

id = sk_SXNETID_value(sx->ids, i);

crypto/openssl/include/openssl/x509v3.h

817

ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone);

crypto/openssl/include/openssl/x509v3.h

818

ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone);

crypto/openssl/include/openssl/x509v3.h

819

ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone);

lib/libc/tests/string/wcscoll_test.c

137

int sx = strcmp(data[i].xval, data[j].xval);

lib/libc/tests/string/wcscoll_test.c

139

ATF_CHECK_MSG(!((sr * sx < 0) ||

lib/libc/tests/string/wcscoll_test.c

140

(sr * sx == 0 && sr + sx != 0)),

lib/libthread_db/arch/i386/libpthread_md.c

60

struct savexmm *sx = (struct savexmm *)&uc->uc_mcontext.mc_fpstate;

lib/libthread_db/arch/i386/libpthread_md.c

61

memcpy(&sx->sv_env, &r->fpr_env, sizeof(r->fpr_env));

lib/libthread_db/arch/i386/libpthread_md.c

63

memcpy(&sx->sv_fp[i].fp_acc, &r->fpr_acc[i], 10);

lib/libthread_db/arch/i386/libpthread_md.c

74

const struct savexmm *sx = (const struct savexmm *)&uc->uc_mcontext.mc_fpstate;

lib/libthread_db/arch/i386/libpthread_md.c

75

memcpy(&r->fpr_env, &sx->sv_env, sizeof(r->fpr_env));

lib/libthread_db/arch/i386/libpthread_md.c

77

memcpy(&r->fpr_acc[i], &sx->sv_fp[i].fp_acc, 10);

lib/msun/src/catrig.c

358

int sx, sy;

lib/msun/src/catrig.c

364

sx = signbit(x);

lib/msun/src/catrig.c

409

if (sx == 0)

lib/msun/src/catrig.c

414

if (sx == 0)

lib/msun/src/catrigf.c

203

int sx, sy;

lib/msun/src/catrigf.c

209

sx = signbit(x);

lib/msun/src/catrigf.c

243

if (sx == 0)

lib/msun/src/catrigf.c

248

if (sx == 0)

lib/msun/src/catrigl.c

223

int sx, sy;

lib/msun/src/catrigl.c

229

sx = signbit(x);

lib/msun/src/catrigl.c

263

if (sx == 0)

lib/msun/src/catrigl.c

268

if (sx == 0)

lib/msun/src/e_fmod.c

102

return Zero[(u_int32_t)sx>>31];

lib/msun/src/e_fmod.c

109

INSERT_WORDS(x,hx|sx,lx);

lib/msun/src/e_fmod.c

116

lx = (hx<<(32-n))|(lx>>n); hx = sx;

lib/msun/src/e_fmod.c

118

lx = hx>>(n-32); hx = sx;

lib/msun/src/e_fmod.c

120

INSERT_WORDS(x,hx|sx,lx);

lib/msun/src/e_fmod.c

29

int32_t hx, hy, hz, ix, iy, n, sx;

lib/msun/src/e_fmod.c

34

sx = hx&0x80000000; /* sign of x */

lib/msun/src/e_fmod.c

35

hx ^= sx; /* |x| */

lib/msun/src/e_fmod.c

45

return Zero[(u_int32_t)sx>>31]; /* |x|=|y| return x*0*/

lib/msun/src/e_fmod.c

93

return Zero[(u_int32_t)sx>>31];

lib/msun/src/e_fmodf.c

30

int32_t hx, hy, hz, ix, iy, n, sx;

lib/msun/src/e_fmodf.c

34

sx = hx&0x80000000; /* sign of x */

lib/msun/src/e_fmodf.c

35

hx ^=sx; /* |x| */

lib/msun/src/e_fmodf.c

44

return Zero[(u_int32_t)sx>>31]; /* |x|=|y| return x*0*/

lib/msun/src/e_fmodf.c

79

return Zero[(u_int32_t)sx>>31];

lib/msun/src/e_fmodf.c

88

return Zero[(u_int32_t)sx>>31];

lib/msun/src/e_fmodf.c

95

SET_FLOAT_WORD(x,hx|sx);

lib/msun/src/e_fmodf.c

99

SET_FLOAT_WORD(x,hx|sx);

lib/msun/src/e_fmodl.c

121

return Zero[sx];

lib/msun/src/e_fmodl.c

130

return Zero[sx];

lib/msun/src/e_fmodl.c

67

int ix,iy,n,sx;

lib/msun/src/e_fmodl.c

71

sx = ux.bits.sign;

lib/msun/src/e_fmodl.c

87

return Zero[sx]; /* |x|=|y| return x*0*/

lib/msun/src/e_remainder.c

34

u_int32_t sx,lx,lp;

lib/msun/src/e_remainder.c

39

sx = hx&0x80000000;

lib/msun/src/e_remainder.c

69

SET_HIGH_WORD(x,hx^sx);

lib/msun/src/e_remainderf.c

26

u_int32_t sx;

lib/msun/src/e_remainderf.c

31

sx = hx&0x80000000;

lib/msun/src/e_remainderf.c

60

SET_FLOAT_WORD(x,hx^sx);

lib/msun/src/s_remquo.c

109

return Zero[(u_int32_t)sx>>31];

lib/msun/src/s_remquo.c

141

SET_HIGH_WORD(x,hx^sx);

lib/msun/src/s_remquo.c

30

int32_t hx,hy,hz,ix,iy,n,sx;

lib/msun/src/s_remquo.c

36

sx = hx&0x80000000; /* sign of x */

lib/msun/src/s_remquo.c

37

hx ^=sx; /* |x| */

lib/msun/src/s_remquo.c

51

return Zero[(u_int32_t)sx>>31]; /* |x|=|y| return x*0*/

lib/msun/src/s_remquof.c

116

SET_FLOAT_WORD(x,hx^sx);

lib/msun/src/s_remquof.c

28

int32_t hx, hy, hz, ix, iy, n, sx;

lib/msun/src/s_remquof.c

34

sx = hx&0x80000000; /* sign of x */

lib/msun/src/s_remquof.c

35

hx ^=sx; /* |x| */

lib/msun/src/s_remquof.c

46

return Zero[(u_int32_t)sx>>31]; /* |x|=|y| return x*0*/

lib/msun/src/s_remquof.c

91

return Zero[(u_int32_t)sx>>31];

lib/msun/src/s_remquol.c

137

return Zero[sx];

lib/msun/src/s_remquol.c

164

ux.bits.sign ^= sx;

lib/msun/src/s_remquol.c

70

int ix,iy,n,q,sx,sxy;

lib/msun/src/s_remquol.c

74

sx = ux.bits.sign;

lib/msun/src/s_remquol.c

75

sxy = sx ^ uy.bits.sign;

lib/msun/src/s_remquol.c

95

return Zero[sx]; /* |x|=|y| return x*0*/

lib/msun/src/s_rint.c

36

int32_t i0,j0,sx;

lib/msun/src/s_rint.c

40

sx = (i0>>31)&1;

lib/msun/src/s_rint.c

49

STRICT_ASSIGN(double,w,TWO52[sx]+x);

lib/msun/src/s_rint.c

50

t = w-TWO52[sx];

lib/msun/src/s_rint.c

52

SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));

lib/msun/src/s_rint.c

82

STRICT_ASSIGN(double,w,TWO52[sx]+x);

lib/msun/src/s_rint.c

83

return w-TWO52[sx];

lib/msun/src/s_rintf.c

31

int32_t i0,j0,sx;

lib/msun/src/s_rintf.c

34

sx = (i0>>31)&1;

lib/msun/src/s_rintf.c

39

STRICT_ASSIGN(float,w,TWO23[sx]+x);

lib/msun/src/s_rintf.c

40

t = w-TWO23[sx];

lib/msun/src/s_rintf.c

42

SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));

lib/msun/src/s_rintf.c

45

STRICT_ASSIGN(float,w,TWO23[sx]+x);

lib/msun/src/s_rintf.c

46

return w-TWO23[sx];

stand/common/gfx_fb.c

1193

uint32_t sx, sy, dx, dy, width, height;

stand/common/gfx_fb.c

1200

sx = s->tr_begin.tp_col * width;

stand/common/gfx_fb.c

1212

sx + state->tg_origin.tp_col,

stand/common/gfx_fb.c

1232

if (dy * pitch + dx > sy * pitch + sx) {

stand/common/gfx_fb.c

1239

uint32_t *source = &state->tg_shadow_fb[sy * pitch + sx];

stand/common/gfx_fb.c

1574

int dx, sx, dy, sy;

stand/common/gfx_fb.c

1581

sx = x0 < x1? 1 : -1;

stand/common/gfx_fb.c

1605

x0 += sx;

stand/common/gfx_fb.c

1611

x2 += sx;

stand/common/gfx_fb.c

1630

int sx, sy, xx, yy, xy, width;

stand/common/gfx_fb.c

1638

sx = x2 - x1;

stand/common/gfx_fb.c

1642

curvature = xx*sy - yy*sx;

stand/common/gfx_fb.c

1644

if (sx*sx + sy*sy > xx*xx+yy*yy) {

stand/common/gfx_fb.c

1646

x0 = sx + x1;

stand/common/gfx_fb.c

1652

xx += sx;

stand/common/gfx_fb.c

1653

sx = x0 < x2? 1 : -1;

stand/common/gfx_fb.c

1654

xx *= sx;

stand/common/gfx_fb.c

1661

if (curvature * sx * sy < 0) {

stand/common/gfx_fb.c

1668

dy = 4 * sx * curvature * (y0 - y1) + yy - xy;

stand/common/gfx_fb.c

1679

x0 += sx;

stand/kshim/bsd_kernel.c

309

sx_init_flags(struct sx *sx, const char *name, int flags)

stand/kshim/bsd_kernel.c

311

sx->owned = 0;

stand/kshim/bsd_kernel.c

315

sx_destroy(struct sx *sx)

stand/kshim/bsd_kernel.c

321

sx_xlock(struct sx *sx)

stand/kshim/bsd_kernel.c

323

sx->owned++;

stand/kshim/bsd_kernel.c

327

sx_xunlock(struct sx *sx)

stand/kshim/bsd_kernel.c

329

sx->owned--;

stand/kshim/bsd_kernel.c

333

sx_xlocked(struct sx *sx)

stand/kshim/bsd_kernel.c

335

return (sx->owned != 0);

stand/kshim/bsd_kernel.h

321

void sx_init_flags(struct sx *, const char *, int);

stand/kshim/bsd_kernel.h

322

void sx_destroy(struct sx *);

stand/kshim/bsd_kernel.h

323

void sx_xlock(struct sx *);

stand/kshim/bsd_kernel.h

324

void sx_xunlock(struct sx *);

stand/kshim/bsd_kernel.h

325

int sx_xlocked(struct sx *);

sys/amd64/vmm/io/ppt.c

72

static struct sx ppt_mtx;

sys/arm/arm/mem.c

78

static struct sx tmppt_lock;

sys/arm/broadcom/bcm2835/bcm2835_mbox.c

87

struct sx property_chan_lock;

sys/arm/broadcom/bcm2835/raspberrypi_gpio.c

57

struct sx sc_sx;

sys/arm/nvidia/as3722.h

262

struct sx lock;

sys/arm/nvidia/as3722.h

279

struct sx gpio_lock;

sys/arm/nvidia/drm2/tegra_host1x.c

93

struct sx lock;

sys/arm64/intel/stratix10-soc-fpga-mgr.c

105

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

110

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

157

sx_xlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

160

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

177

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

184

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

198

sx_xlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

201

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

208

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

216

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

284

sx_init(&sc->sx, "s10 fpga");

sys/arm64/intel/stratix10-soc-fpga-mgr.c

302

sx_destroy(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

71

struct sx sx;

sys/arm64/intel/stratix10-soc-fpga-mgr.c

86

sx_xlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

88

sx_xunlock(&sc->sx);

sys/arm64/intel/stratix10-soc-fpga-mgr.c

95

sx_xunlock(&sc->sx);

sys/arm64/iommu/iommu.c

74

static struct sx iommu_sx;

sys/arm64/nvidia/tegra210/max77620.h

199

struct sx lock;

sys/arm64/nvidia/tegra210/max77620.h

216

struct sx gpio_lock;

sys/arm64/nvidia/tegra210/max77620_rtc.c

90

struct sx lock;

sys/cam/ctl/ctl_backend_block.c

190

struct sx modify_lock;

sys/cam/ctl/ctl_backend_ramdisk.c

111

struct sx page_lock;

sys/cam/ctl/ctl_backend_ramdisk.c

128

struct sx modify_lock;

sys/cam/scsi/scsi_enc_internal.h

138

struct sx enc_cache_lock;

sys/cddl/compat/opensolaris/sys/rwlock.h

46

typedef struct sx krwlock_t;

sys/cddl/compat/opensolaris/sys/rwlock.h

64

bzero((lock), sizeof(struct sx)); \

sys/cddl/dev/kinst/trampoline.c

50

static struct sx kinst_tramp_sx;

sys/compat/linux/linux_common.c

42

struct sx linux_ioctl_sx;

sys/compat/linux/linux_emul.h

66

struct sx pem_sx; /* lock for this struct */

sys/compat/linux/linux_ioctl.c

134

static struct sx linux_ioctl_sx;

sys/compat/linux/linux_ioctl.c

138

extern struct sx linux_ioctl_sx;

sys/compat/linuxkpi/common/include/linux/mutex.h

105

if (unlikely(sx_xholder(&lock->sx) == curthread))

sys/compat/linuxkpi/common/include/linux/mutex.h

126

return ((struct thread *)SX_OWNER(m->sx.sx_lock) != NULL);

sys/compat/linuxkpi/common/include/linux/mutex.h

132

return (sx_xlocked(&m->sx));

sys/compat/linuxkpi/common/include/linux/mutex.h

158

SX_SYSINIT_FLAGS(lock, &(lock).sx, mutex_name(#lock), SX_DUPOK)

sys/compat/linuxkpi/common/include/linux/mutex.h

164

sx_init_flags(&m->sx, name, flags);

sys/compat/linuxkpi/common/include/linux/mutex.h

172

sx_destroy(&m->sx);

sys/compat/linuxkpi/common/include/linux/mutex.h

44

struct sx sx;

sys/compat/linuxkpi/common/include/linux/mutex.h

60

sx_xlock(&(_m)->sx); \

sys/compat/linuxkpi/common/include/linux/mutex.h

88

sx_xunlock(&(_m)->sx); \

sys/compat/linuxkpi/common/include/linux/mutex.h

93

!!sx_try_xlock(&(_m)->sx); \

sys/compat/linuxkpi/common/include/linux/rwsem.h

39

struct sx sx;

sys/compat/linuxkpi/common/include/linux/rwsem.h

42

#define down_write(_rw) sx_xlock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

43

#define up_write(_rw) sx_xunlock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

44

#define down_read(_rw) sx_slock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

45

#define up_read(_rw) sx_sunlock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

46

#define down_read_trylock(_rw) !!sx_try_slock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

48

#define down_write_trylock(_rw) !!sx_try_xlock(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

50

#define downgrade_write(_rw) sx_downgrade(&(_rw)->sx)

sys/compat/linuxkpi/common/include/linux/rwsem.h

79

sx_init_flags(&rw->sx, name, SX_NOWITNESS);

sys/compat/linuxkpi/common/include/linux/ww_mutex.h

103

else if ((struct thread *)SX_OWNER(lock->base.sx.sx_lock) == curthread)

sys/compat/linuxkpi/common/include/linux/ww_mutex.h

65

sx_xlocked(&(_m)->base.sx)

sys/compat/linuxkpi/common/include/linux/ww_mutex.h

92

else if ((struct thread *)SX_OWNER(lock->base.sx.sx_lock) == curthread)

sys/compat/linuxkpi/common/src/linux_80211.h

250

struct sx lvif_sx;

sys/compat/linuxkpi/common/src/linux_80211.h

255

struct sx mc_sx;

sys/compat/linuxkpi/common/src/linux_i2c.c

53

static struct sx lkpi_sx_i2c;

sys/compat/linuxkpi/common/src/linux_i2cbb.c

58

static struct sx lkpi_sx_i2cbb;

sys/compat/linuxkpi/common/src/linux_lock.c

105

other->lock->base.sx.sx_lock) == curthread) {

sys/compat/linuxkpi/common/src/linux_lock.c

120

} while (sx_try_xlock(&lock->base.sx) == 0);

sys/compat/linuxkpi/common/src/linux_lock.c

125

if ((struct thread *)SX_OWNER(lock->base.sx.sx_lock) == NULL)

sys/compat/linuxkpi/common/src/linux_lock.c

141

sx_xunlock(&lock->base.sx);

sys/compat/linuxkpi/common/src/linux_lock.c

152

error = -sx_xlock_sig(&m->sx);

sys/compat/linuxkpi/common/src/linux_lock.c

165

error = -sx_slock_sig(&rw->sx);

sys/compat/linuxkpi/common/src/linux_lock.c

178

error = -sx_xlock_sig(&rw->sx);

sys/compat/linuxkpi/common/src/linux_lock.c

83

if (unlikely(sx_try_xlock(&lock->base.sx) == 0)) {

sys/compat/linuxkpi/common/src/linux_lock.c

90

SX_OWNER(lock->base.sx.sx_lock);

sys/compat/linuxkpi/common/src/linux_shrinker.c

38

static struct sx sx_shrinker;

sys/ddb/db_capture.c

80

struct sx db_capture_sx; /* Lock against user thread races. */

sys/dev/acpica/acpivar.h

177

static struct sx sys##_sxlock; \

sys/dev/atopcase/atopcase_var.h

100

struct sx sc_sx;

sys/dev/atopcase/atopcase_var.h

92

struct sx sc_write_sx;

sys/dev/axgbe/xgbe.h

1253

struct sx an_mutex;

sys/dev/backlight/backlight.c

43

static struct sx backlight_sx;

sys/dev/bxe/bxe.h

1401

struct sx core_sx;

sys/dev/clk/clk.c

117

struct sx lock; /* Lock for this clock */

sys/dev/clk/clk.c

167

static struct sx clk_topo_lock;

sys/dev/cxgbe/t4_main.c

14199

static struct sx mlu; /* mod load unload */

sys/dev/cxgbe/t4_main.c

296

static struct sx t4_list_lock;

sys/dev/cxgbe/t4_main.c

299

static struct sx t4_uld_list_lock;

sys/dev/cxgbe/t4_tracer.c

84

static struct sx t4_trace_lock;

sys/dev/drm2/drmP.h

1090

struct sx object_name_lock;

sys/dev/drm2/drmP.h

1195

extern struct sx drm_global_mutex;

sys/dev/drm2/drmP.h

976

struct sx dev_struct_lock; /**< For others */

sys/dev/drm2/drm_crtc.h

768

struct sx mutex; /* protects configuration (mode lists etc.) */

sys/dev/drm2/drm_drv.c

56

struct sx drm_global_mutex;

sys/dev/drm2/drm_global.c

38

struct sx mutex;

sys/dev/drm2/ttm/ttm_bo_driver.h

280

struct sx io_reserve_mutex;

sys/dev/drm2/ttm/ttm_bo_driver.h

488

struct sx device_list_mutex;

sys/dev/e1000/if_em.c

5436

struct sx *iflib_ctx_lock = iflib_ctx_lock_get(sc->ctx);

sys/dev/ena/ena.c

190

struct sx ena_global_lock;

sys/dev/ena/ena.h

547

extern struct sx ena_global_lock;

sys/dev/etherswitch/e6000sw/e6000sw.c

284

sx_init(&sc->sx, "e6000sw_tmp");

sys/dev/etherswitch/e6000sw/e6000sw.c

288

sx_destroy(&sc->sx);

sys/dev/etherswitch/e6000sw/e6000sw.c

552

sx_init(&sc->sx, "e6000sw");

sys/dev/etherswitch/e6000sw/e6000sw.c

65

#define E6000SW_LOCK(_sc) sx_xlock(&(_sc)->sx)

sys/dev/etherswitch/e6000sw/e6000sw.c

66

#define E6000SW_UNLOCK(_sc) sx_unlock(&(_sc)->sx)

sys/dev/etherswitch/e6000sw/e6000sw.c

67

#define E6000SW_LOCK_ASSERT(_sc, _what) sx_assert(&(_sc)->sx, (_what))

sys/dev/etherswitch/e6000sw/e6000sw.c

68

#define E6000SW_TRYLOCK(_sc) sx_tryxlock(&(_sc)->sx)

sys/dev/etherswitch/e6000sw/e6000sw.c

69

#define E6000SW_LOCKED(_sc) sx_xlocked(&(_sc)->sx)

sys/dev/etherswitch/e6000sw/e6000sw.c

86

struct sx sx;

sys/dev/etherswitch/e6000sw/e6000sw.c

889

sx_destroy(&sc->sx);

sys/dev/evdev/evdev_private.h

121

struct sx ev_list_lock; /* Client list lock */

sys/dev/evdev/uinput.c

114

struct sx ucs_lock;

sys/dev/evdev/uinput.c

133

struct sx *sx = arg;

sys/dev/evdev/uinput.c

135

sx_xlock(sx);

sys/dev/evdev/uinput.c

141

struct sx *sx = arg;

sys/dev/evdev/uinput.c

143

sx_unlock(sx);

sys/dev/evdev/uinput.c

151

sx_assert((struct sx*)arg, SA_XLOCKED);

sys/dev/evdev/uinput.c

153

sx_assert((struct sx*)arg, SA_UNLOCKED);

sys/dev/filemon/filemon.c

83

struct sx lock; /* Lock for this filemon. */

sys/dev/gve/gve.h

636

struct sx gve_iface_lock;

sys/dev/gve/gve_main.c

51

struct sx gve_global_lock;

sys/dev/hid/hconf.c

104

struct sx lock;

sys/dev/hid/hidbus.c

205

sx_xlock(&sc->sx);

sys/dev/hid/hidbus.c

207

sx_unlock(&sc->sx);

sys/dev/hid/hidbus.c

352

sx_init(&sc->sx, "hidbus ivar list lock");

sys/dev/hid/hidbus.c

388

sx_destroy(&sc->sx);

sys/dev/hid/hidbus.c

425

sx_xlock(&sc->sx);

sys/dev/hid/hidbus.c

428

sx_unlock(&sc->sx);

sys/dev/hid/hidbus.c

607

if (sx_xlock_sig(&sc->sx) != 0)

sys/dev/hid/hidbus.c

613

sx_unlock(&sc->sx);

sys/dev/hid/hidbus.c

628

if (sx_xlock_sig(&sc->sx) != 0)

sys/dev/hid/hidbus.c

636

sx_unlock(&sc->sx);

sys/dev/hid/hidbus.c

75

struct sx sx;

sys/dev/hid/ps4dshock.c

665

struct sx lock;

sys/dev/hptmv/entry.c

135

static struct sx hptmv_list_lock;

sys/dev/hyperv/hvsock/hv_sock.c

138

static struct sx hvs_trans_socks_sx;

sys/dev/hyperv/netvsc/if_hnvar.h

196

struct sx hn_lock;

sys/dev/hyperv/vmbus/vmbus_chanvar.h

142

struct sx ch_orphan_lock;

sys/dev/ice/ice_iflib.h

341

struct sx *iflib_ctx_lock;

sys/dev/ice/ice_rdma_internal.h

104

struct sx mtx;

sys/dev/ichiic/ig4_var.h

109

struct sx call_lock;

sys/dev/iicbus/adc/ad7418.c

61

struct sx sc_lock;

sys/dev/iicbus/adc/ads111x.c

158

struct sx lock;

sys/dev/iicbus/controller/qcom/geni_iic_var.h

62

struct sx bus_lock;

sys/dev/iicbus/controller/qcom/geni_iic_var.h

63

struct sx real_bus_lock;

sys/dev/iicbus/gpio/pcf8574.c

72

struct sx lock;

sys/dev/iicbus/gpio/tca64xx.c

97

struct sx mtx;

sys/dev/iicbus/iic.c

56

struct sx lock;

sys/dev/iicbus/pmic/act8846.h

39

struct sx lock;

sys/dev/iscsi/icl.c

67

struct sx sc_lock;

sys/dev/iscsi/icl_soft_proxy.c

96

struct sx il_lock;

sys/dev/iscsi/iscsi.h

129

struct sx sc_lock;

sys/dev/iser/icl_iser.h

436

struct sx state_mutex;

sys/dev/iser/icl_iser.h

461

struct sx device_list_mutex;

sys/dev/iser/icl_iser.h

465

struct sx close_conns_mutex;

sys/dev/isl/isl.c

70

struct sx isl_sx;

sys/dev/ksyms/ksyms.c

93

static struct sx ksyms_mtx;

sys/dev/led/led.c

45

static struct sx led_sx;

sys/dev/mana/gdma.h

423

struct sx eq_test_event_sx;

sys/dev/mana/mana.h

492

struct sx apc_lock;

sys/dev/md/md.c

209

static struct sx md_sx;

sys/dev/mem/memutil.c

36

static struct sx mr_lock;

sys/dev/mfi/mfivar.h

325

struct sx mfi_config_lock;

sys/dev/mge/if_mge.c

204

static struct sx sx_smi;

sys/dev/mlx/mlxvar.h

155

struct sx mlx_config_lock;

sys/dev/mlx5/driver.h

318

struct sx dma_sx;

sys/dev/mlx5/mlx5_en/en.h

1089

struct sx state_lock; /* Protects Interface state */

sys/dev/mlx5/mlx5_en/en_rl.h

153

struct sx rl_sxlock;

sys/dev/mlx5/mlx5_fpga_tools/tools.h

50

struct sx lock;

sys/dev/mlx5/mlx5_ib/mlx5_ib.h

730

struct sx lock;

sys/dev/netmap/netmap_kern.h

92

#define NM_MTX_T struct sx /* OS-specific mutex (sleepable) */

sys/dev/nvmf/controller/ctl_frontend_nvmf.c

56

static struct sx nvmft_ports_lock;

sys/dev/nvmf/host/nvmf_var.h

83

struct sx connection_lock;

sys/dev/nvmf/nvmf_transport.c

35

static struct sx nvmf_transports_lock;

sys/dev/nvram/nvram.c

68

static struct sx nvram_lock;

sys/dev/pbio/pbio.c

115

struct sx lock;

sys/dev/phy/phy.c

71

struct sx phynode_topo_lock;

sys/dev/phy/phy_internal.h

55

struct sx lock; /* Lock for this phy */

sys/dev/phy/phy_internal.h

79

extern struct sx phynode_topo_lock;

sys/dev/powermac_nvram/powermac_nvramvar.h

50

struct sx sc_lock;

sys/dev/ppbus/ppi.c

68

struct sx ppi_lock;

sys/dev/ppbus/pps.c

50

struct sx lock;

sys/dev/proto/proto_busdma.h

61

struct sx sxlck;

sys/dev/qat/include/common/adf_accel_devices.h

618

struct sx lock;

sys/dev/qat/include/common/adf_cfg.h

32

struct sx lock;

sys/dev/qat/qat_common/adf_ctl_drv.c

41

static struct sx adf_ctl_lock;

sys/dev/qat/qat_common/adf_freebsd_dev_processes.c

100

struct sx processes_list_sema;

sys/dev/qlnx/qlnxe/qlnx_def.h

392

struct sx hw_lock;

sys/dev/regulator/regulator.c

118

struct sx lock; /* Lock for this regulator */

sys/dev/regulator/regulator.c

147

static struct sx regnode_topo_lock;

sys/dev/sfxge/sfxge.h

268

struct sx softc_lock;

sys/dev/snp/snp.c

55

static struct sx snp_register_lock;

sys/dev/sound/pcm/feeder_rate.c

450

uint8_t *sx, *sy; \

sys/dev/sound/pcm/feeder_rate.c

454

sx = info->z_delay + (info->z_start * info->channels * \

sys/dev/sound/pcm/feeder_rate.c

456

sy = sx - (info->channels * PCM_##BIT##_BPS); \

sys/dev/sound/pcm/feeder_rate.c

461

x = pcm_sample_read(sx, AFMT_##SIGN##BIT##_##ENDIAN); \

sys/dev/sound/pcm/feeder_rate.c

465

sx += PCM_##BIT##_BPS; \

sys/dev/sound/sndstat.c

100

struct sx lock;

sys/dev/sound/sndstat.c

109

static struct sx sndstat_lock;

sys/dev/syscon/syscon.c

80

static struct sx syscon_topo_lock;

sys/dev/tpm/tpm20.h

124

struct sx dev_lock;

sys/dev/usb/controller/xhci.h

508

struct sx sc_cmd_sx;

sys/dev/usb/misc/cp2112.c

226

struct sx gpio_lock;

sys/dev/usb/usb_dev.c

157

static struct sx usb_sym_lock;

sys/dev/usb/usb_dev.h

112

struct sx fs_fastpath_lock;

sys/dev/usb/usb_device.h

197

struct sx enum_sx;

sys/dev/usb/usb_device.h

198

struct sx sr_sx;

sys/dev/usb/usb_device.h

199

struct sx ctrl_sx;

sys/dev/vmm/vmm_dev.c

97

static struct sx vmmdev_mtx;

sys/dev/vmm/vmm_mem.h

62

struct sx mem_segs_lock;

sys/dev/vmm/vmm_vm.h

134

struct sx vcpus_init_lock; /* (o) */

sys/dev/vnic/nic.h

294

struct sx core_sx;

sys/dev/wg/if_wg.c

247

struct sx sc_lock;

sys/dev/wg/if_wg.c

269

static struct sx wg_sx;

sys/dev/xen/evtchn/evtchn_dev.c

81

struct sx ring_cons_mutex; /* protect against concurrent readers */

sys/dev/xen/xenstore/xenstore.c

163

struct sx request_mutex;

sys/dev/xen/xenstore/xenstore.c

214

struct sx xenwatch_mutex;

sys/fs/autofs/autofs.h

118

struct sx sc_lock;

sys/fs/autofs/autofs.h

77

struct sx an_vnode_lock;

sys/fs/autofs/autofs.h

89

struct sx am_lock;

sys/fs/cuse/cuse.c

114

struct sx sx;

sys/fs/cuse/cuse.c

1473

sx_destroy(&pccmd->sx);

sys/fs/cuse/cuse.c

1530

sx_init(&pccmd->sx, "cuse-client-sx");

sys/fs/cuse/cuse.c

288

sx_xlock(&pccmd->sx);

sys/fs/cuse/cuse.c

294

sx_xunlock(&pccmd->sx);

sys/fs/devfs/devfs.h

166

struct sx dm_lock;

sys/fs/devfs/devfs_rule.c

129

static struct sx sx_rules;

sys/geom/concat/g_concat.h

76

struct sx sc_disks_lock; /* synchronizes modification of sc_disks */

sys/geom/eli/g_eli.c

107

static struct sx g_eli_umalock; /* Controls changes to UMA zone. */

sys/geom/geom.h

357

extern struct sx topology_lock;

sys/geom/geom_kern.c

58

struct sx topology_lock;

sys/geom/mirror/g_mirror.h

184

struct sx sc_lock;

sys/geom/raid/g_raid.h

297

struct sx sc_lock; /* Main node lock. */

sys/geom/raid3/g_raid3.h

189

struct sx sc_lock;

sys/i386/i386/mem.c

74

static struct sx memsxlock;

sys/i386/include/pcpu.h

78

struct sx pc_copyout_slock; \

sys/kern/imgact_binmisc.c

102

static struct sx interp_list_sx;

sys/kern/kern_acct.c

139

static struct sx acct_sx;

sys/kern/kern_cpu.c

68

struct sx lock;

sys/kern/kern_fail.c

120

static struct sx sx_fp_set;

sys/kern/kern_jail.c

151

struct sx allprison_lock;

sys/kern/kern_ktrace.c

157

static struct sx ktrace_sx;

sys/kern/kern_linker.c

107

static struct sx kld_sx; /* kernel linker lock */

sys/kern/kern_lockf.c

205

struct sx lock;

sys/kern/kern_lockf.c

209

static struct sx lf_lock_states_lock;

sys/kern/kern_lockf.c

271

static struct sx lf_owner_graph_lock;

sys/kern/kern_lockf.c

355

struct sx *chainlock;

sys/kern/kern_module.c

61

struct sx modules_sx;

sys/kern/kern_osd.c

53

struct sx osd_module_lock;

sys/kern/kern_pmc.c

96

struct sx pmc_sx;

sys/kern/kern_proc.c

129

struct sx *pidhashtbl_lock;

sys/kern/kern_proc.c

135

struct sx __exclusive_cache_line allproc_lock;

sys/kern/kern_proc.c

136

struct sx __exclusive_cache_line proctree_lock;

sys/kern/kern_proc.c

3465

static struct sx stop_all_proc_blocker;

sys/kern/kern_sharedpage.c

57

static struct sx shared_page_alloc_sx;

sys/kern/kern_sx.c

1003

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, xp,

sys/kern/kern_sx.c

1005

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1007

__func__, sx, (void *)*xp,

sys/kern/kern_sx.c

1017

_sx_slock_hard(struct sx *sx, int opts, uintptr_t x LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

1045

if (__sx_slock_try(sx, td, &x, false LOCK_FILE_LINE_ARG))

sys/kern/kern_sx.c

1048

all_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1068

lock_profile_obtain_lock_failed(&sx->lock_object, false, &contested,

sys/kern/kern_sx.c

1075

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

1082

if (__sx_slock_try(sx, td, &x, false LOCK_FILE_LINE_ARG))

sys/kern/kern_sx.c

1100

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1103

__func__, sx, owner);

sys/kern/kern_sx.c

1106

"lockname:\"%s\"", sx->lock_object.lo_name);

sys/kern/kern_sx.c

1109

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

112

#define sx_recursed(sx) ((sx)->sx_recurse != 0)

sys/kern/kern_sx.c

1120

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1126

sx->lock_object.lo_name);

sys/kern/kern_sx.c

1130

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1154

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

1155

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1159

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

1172

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

1173

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1185

if (!atomic_fcmpset_ptr(&sx->sx_lock, &x,

sys/kern/kern_sx.c

1188

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1190

__func__, sx);

sys/kern/kern_sx.c

1197

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1199

__func__, sx);

sys/kern/kern_sx.c

1202

sleep_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1204

sleepq_add(&sx->lock_object, NULL, sx->lock_object.lo_name,

sys/kern/kern_sx.c

1212

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

1214

sleepq_wait(&sx->lock_object, 0);

sys/kern/kern_sx.c

1216

error = sleepq_wait_sig(&sx->lock_object, 0);

sys/kern/kern_sx.c

1217

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

1219

sleep_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1223

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1226

__func__, sx);

sys/kern/kern_sx.c

1229

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1231

__func__, sx);

sys/kern/kern_sx.c

1232

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1234

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

1240

all_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1242

LOCKSTAT_RECORD4(sx__block, sx, sleep_time,

sys/kern/kern_sx.c

1246

LOCKSTAT_RECORD4(sx__spin, sx, all_time - sleep_time,

sys/kern/kern_sx.c

1252

LOCKSTAT_PROFILE_OBTAIN_RWLOCK_SUCCESS(sx__acquire, sx,

sys/kern/kern_sx.c

1260

_sx_slock_int(struct sx *sx, int opts LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

1269

curthread, sx, file, line));

sys/kern/kern_sx.c

1270

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

1271

("sx_slock() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

1272

WITNESS_CHECKORDER(&sx->lock_object, LOP_NEWORDER, file, line, NULL);

sys/kern/kern_sx.c

1276

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1278

!__sx_slock_try(sx, td, &x, true LOCK_FILE_LINE_ARG)))

sys/kern/kern_sx.c

1279

error = _sx_slock_hard(sx, opts, x LOCK_FILE_LINE_ARG);

sys/kern/kern_sx.c

1281

lock_profile_obtain_lock_success(&sx->lock_object, false, 0, 0,

sys/kern/kern_sx.c

1284

LOCK_LOG_LOCK("SLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

1285

WITNESS_LOCK(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

1292

_sx_slock(struct sx *sx, int opts, const char *file, int line)

sys/kern/kern_sx.c

1295

return (_sx_slock_int(sx, opts LOCK_FILE_LINE_ARG));

sys/kern/kern_sx.c

1299

_sx_sunlock_try(struct sx *sx, struct thread *td, uintptr_t *xp)

sys/kern/kern_sx.c

1304

if (atomic_fcmpset_rel_ptr(&sx->sx_lock, xp,

sys/kern/kern_sx.c

1306

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1309

__func__, sx, (void *)*xp,

sys/kern/kern_sx.c

1322

_sx_sunlock_hard(struct sx *sx, struct thread *td, uintptr_t x

sys/kern/kern_sx.c

1330

if (_sx_sunlock_try(sx, td, &x))

sys/kern/kern_sx.c

1333

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

1334

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1336

if (_sx_sunlock_try(sx, td, &x))

sys/kern/kern_sx.c

1352

if (!atomic_fcmpset_rel_ptr(&sx->sx_lock, &x, setx))

sys/kern/kern_sx.c

1354

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1356

"exclusive queue", __func__, sx);

sys/kern/kern_sx.c

1357

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0, queue);

sys/kern/kern_sx.c

1361

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

1363

LOCKSTAT_PROFILE_RELEASE_RWLOCK(sx__release, sx, LOCKSTAT_READER);

sys/kern/kern_sx.c

1367

_sx_sunlock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

1372

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

1373

("sx_sunlock() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

1374

_sx_assert(sx, SA_SLOCKED, file, line);

sys/kern/kern_sx.c

1375

WITNESS_UNLOCK(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

1376

LOCK_LOG_LOCK("SUNLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

1379

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

1381

!_sx_sunlock_try(sx, td, &x)))

sys/kern/kern_sx.c

1382

_sx_sunlock_hard(sx, td, x LOCK_FILE_LINE_ARG);

sys/kern/kern_sx.c

1384

lock_profile_release_lock(&sx->lock_object, false);

sys/kern/kern_sx.c

139

#define _sx_assert(sx, what, file, line)

sys/kern/kern_sx.c

1390

_sx_sunlock(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

1393

_sx_sunlock_int(sx LOCK_FILE_LINE_ARG);

sys/kern/kern_sx.c

1407

_sx_assert(const struct sx *sx, int what, const char *file, int line)

sys/kern/kern_sx.c

1427

witness_assert(&sx->lock_object, what, file, line);

sys/kern/kern_sx.c

1434

if (sx->sx_lock == SX_LOCK_UNLOCKED ||

sys/kern/kern_sx.c

1435

(!(sx->sx_lock & SX_LOCK_SHARED) && (slocked ||

sys/kern/kern_sx.c

1436

sx_xholder(sx) != curthread)))

sys/kern/kern_sx.c

1438

sx->lock_object.lo_name, slocked ? "share " : "",

sys/kern/kern_sx.c

1441

if (!(sx->sx_lock & SX_LOCK_SHARED)) {

sys/kern/kern_sx.c

1442

if (sx_recursed(sx)) {

sys/kern/kern_sx.c

1445

sx->lock_object.lo_name, file,

sys/kern/kern_sx.c

1449

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1456

if (sx_xholder(sx) != curthread)

sys/kern/kern_sx.c

1458

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1459

if (sx_recursed(sx)) {

sys/kern/kern_sx.c

146

static SYSCTL_NODE(_debug, OID_AUTO, sx, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,

sys/kern/kern_sx.c

1462

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1465

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1469

witness_assert(&sx->lock_object, what, file, line);

sys/kern/kern_sx.c

1476

if (sx_xholder(sx) == curthread)

sys/kern/kern_sx.c

1478

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1493

const struct sx *sx;

sys/kern/kern_sx.c

1495

sx = (const struct sx *)lock;

sys/kern/kern_sx.c

1498

if (sx->sx_lock == SX_LOCK_UNLOCKED)

sys/kern/kern_sx.c

1500

else if (sx->sx_lock == SX_LOCK_DESTROYED) {

sys/kern/kern_sx.c

1503

} else if (sx->sx_lock & SX_LOCK_SHARED)

sys/kern/kern_sx.c

1504

db_printf("SLOCK: %ju\n", (uintmax_t)SX_SHARERS(sx->sx_lock));

sys/kern/kern_sx.c

1506

td = sx_xholder(sx);

sys/kern/kern_sx.c

1509

if (sx_recursed(sx))

sys/kern/kern_sx.c

1510

db_printf(" recursed: %d\n", sx->sx_recurse);

sys/kern/kern_sx.c

1514

switch(sx->sx_lock &

sys/kern/kern_sx.c

1538

const struct sx *sx;

sys/kern/kern_sx.c

1546

sx = td->td_wchan;

sys/kern/kern_sx.c

1548

LOCK_CLASS(&sx->lock_object) != &lock_class_sx ||

sys/kern/kern_sx.c

1549

sx->lock_object.lo_name != td->td_wmesg)

sys/kern/kern_sx.c

1553

db_printf("blocked on lock %p (%s) \"%s\" ", &sx->lock_object,

sys/kern/kern_sx.c

1555

*ownerp = sx_xholder(sx);

sys/kern/kern_sx.c

1556

if (sx->sx_lock & SX_LOCK_SHARED)

sys/kern/kern_sx.c

1558

(uintmax_t)SX_SHARERS(sx->sx_lock));

sys/kern/kern_sx.c

178

sx_assert((const struct sx *)lock, what);

sys/kern/kern_sx.c

184

struct sx *sx;

sys/kern/kern_sx.c

186

sx = (struct sx *)lock;

sys/kern/kern_sx.c

188

sx_slock(sx);

sys/kern/kern_sx.c

190

sx_xlock(sx);

sys/kern/kern_sx.c

196

struct sx *sx;

sys/kern/kern_sx.c

198

sx = (struct sx *)lock;

sys/kern/kern_sx.c

199

sx_assert(sx, SA_LOCKED | SA_NOTRECURSED);

sys/kern/kern_sx.c

200

if (sx_xlocked(sx)) {

sys/kern/kern_sx.c

201

sx_xunlock(sx);

sys/kern/kern_sx.c

204

sx_sunlock(sx);

sys/kern/kern_sx.c

213

const struct sx *sx;

sys/kern/kern_sx.c

216

sx = (const struct sx *)lock;

sys/kern/kern_sx.c

217

x = sx->sx_lock;

sys/kern/kern_sx.c

233

sx_init_flags(struct sx *sx, const char *description, int opts)

sys/kern/kern_sx.c

239

ASSERT_ATOMIC_LOAD_PTR(sx->sx_lock,

sys/kern/kern_sx.c

241

&sx->sx_lock));

sys/kern/kern_sx.c

257

lock_init(&sx->lock_object, &lock_class_sx, description, NULL, flags);

sys/kern/kern_sx.c

258

sx->sx_lock = SX_LOCK_UNLOCKED;

sys/kern/kern_sx.c

259

sx->sx_recurse = 0;

sys/kern/kern_sx.c

263

sx_destroy(struct sx *sx)

sys/kern/kern_sx.c

266

KASSERT(sx->sx_lock == SX_LOCK_UNLOCKED, ("sx lock still held"));

sys/kern/kern_sx.c

267

KASSERT(sx->sx_recurse == 0, ("sx lock still recursed"));

sys/kern/kern_sx.c

268

sx->sx_lock = SX_LOCK_DESTROYED;

sys/kern/kern_sx.c

269

lock_destroy(&sx->lock_object);

sys/kern/kern_sx.c

273

sx_try_slock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

282

curthread, sx, file, line));

sys/kern/kern_sx.c

284

x = sx->sx_lock;

sys/kern/kern_sx.c

287

("sx_try_slock() of destroyed sx %p @ %s:%d", sx, file,

sys/kern/kern_sx.c

291

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, x + SX_ONE_SHARER)) {

sys/kern/kern_sx.c

292

LOCK_LOG_TRY("SLOCK", &sx->lock_object, 0, 1, file, line);

sys/kern/kern_sx.c

293

WITNESS_LOCK(&sx->lock_object, LOP_TRYLOCK, file, line);

sys/kern/kern_sx.c

295

sx, 0, 0, file, line, LOCKSTAT_READER);

sys/kern/kern_sx.c

302

LOCK_LOG_TRY("SLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

307

sx_try_slock_(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

310

return (sx_try_slock_int(sx LOCK_FILE_LINE_ARG));

sys/kern/kern_sx.c

314

_sx_xlock(struct sx *sx, int opts, const char *file, int line)

sys/kern/kern_sx.c

322

curthread, sx, file, line));

sys/kern/kern_sx.c

323

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

324

("sx_xlock() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

325

WITNESS_CHECKORDER(&sx->lock_object, LOP_NEWORDER | LOP_EXCLUSIVE, file,

sys/kern/kern_sx.c

329

if (!atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid))

sys/kern/kern_sx.c

330

error = _sx_xlock_hard(sx, x, opts LOCK_FILE_LINE_ARG);

sys/kern/kern_sx.c

332

LOCKSTAT_PROFILE_OBTAIN_RWLOCK_SUCCESS(sx__acquire, sx,

sys/kern/kern_sx.c

335

LOCK_LOG_LOCK("XLOCK", &sx->lock_object, 0, sx->sx_recurse,

sys/kern/kern_sx.c

337

WITNESS_LOCK(&sx->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_sx.c

345

sx_try_xlock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

359

curthread, sx, file, line));

sys/kern/kern_sx.c

360

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

361

("sx_try_xlock() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

367

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid))

sys/kern/kern_sx.c

371

if (x == tid && (sx->lock_object.lo_flags & LO_RECURSABLE)) {

sys/kern/kern_sx.c

372

sx->sx_recurse++;

sys/kern/kern_sx.c

373

atomic_set_ptr(&sx->sx_lock, SX_LOCK_RECURSED);

sys/kern/kern_sx.c

380

LOCK_LOG_TRY("XLOCK", &sx->lock_object, 0, rval, file, line);

sys/kern/kern_sx.c

382

WITNESS_LOCK(&sx->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_sx.c

386

sx, 0, 0, file, line, LOCKSTAT_WRITER);

sys/kern/kern_sx.c

394

sx_try_xlock_(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

397

return (sx_try_xlock_int(sx LOCK_FILE_LINE_ARG));

sys/kern/kern_sx.c

401

_sx_xunlock(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

404

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

405

("sx_xunlock() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

406

_sx_assert(sx, SA_XLOCKED, file, line);

sys/kern/kern_sx.c

407

WITNESS_UNLOCK(&sx->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_sx.c

408

LOCK_LOG_LOCK("XUNLOCK", &sx->lock_object, 0, sx->sx_recurse, file,

sys/kern/kern_sx.c

411

_sx_xunlock_hard(sx, (uintptr_t)curthread, file, line);

sys/kern/kern_sx.c

413

__sx_xunlock(sx, curthread, file, line);

sys/kern/kern_sx.c

424

sx_try_upgrade_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

433

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

434

("sx_try_upgrade() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

435

_sx_assert(sx, SA_SLOCKED, file, line);

sys/kern/kern_sx.c

443

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

448

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x,

sys/kern/kern_sx.c

454

LOCK_LOG_TRY("XUPGRADE", &sx->lock_object, 0, success, file, line);

sys/kern/kern_sx.c

457

WITNESS_UPGRADE(&sx->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_sx.c

459

LOCKSTAT_RECORD0(sx__upgrade, sx);

sys/kern/kern_sx.c

465

sx_try_upgrade_(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

468

return (sx_try_upgrade_int(sx LOCK_FILE_LINE_ARG));

sys/kern/kern_sx.c

475

sx_downgrade_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

482

KASSERT(sx->sx_lock != SX_LOCK_DESTROYED,

sys/kern/kern_sx.c

483

("sx_downgrade() of destroyed sx %p @ %s:%d", sx, file, line));

sys/kern/kern_sx.c

484

_sx_assert(sx, SA_XLOCKED | SA_NOTRECURSED, file, line);

sys/kern/kern_sx.c

486

if (sx_recursed(sx))

sys/kern/kern_sx.c

490

WITNESS_DOWNGRADE(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

503

x = sx->sx_lock;

sys/kern/kern_sx.c

505

atomic_cmpset_rel_ptr(&sx->sx_lock, x, SX_SHARERS_LOCK(1) |

sys/kern/kern_sx.c

513

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

519

x = sx->sx_lock;

sys/kern/kern_sx.c

520

atomic_store_rel_ptr(&sx->sx_lock, SX_SHARERS_LOCK(1) |

sys/kern/kern_sx.c

523

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0,

sys/kern/kern_sx.c

525

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

529

LOCK_LOG_LOCK("XDOWNGRADE", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

530

LOCKSTAT_RECORD0(sx__downgrade, sx);

sys/kern/kern_sx.c

534

sx_downgrade_(struct sx *sx, const char *file, int line)

sys/kern/kern_sx.c

537

sx_downgrade_int(sx LOCK_FILE_LINE_ARG);

sys/kern/kern_sx.c

564

_sx_xlock_hard(struct sx *sx, uintptr_t x, int opts LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

598

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid))

sys/kern/kern_sx.c

603

all_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

616

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

620

KASSERT((sx->lock_object.lo_flags & LO_RECURSABLE) != 0,

sys/kern/kern_sx.c

622

sx, file, line));

sys/kern/kern_sx.c

623

sx->sx_recurse++;

sys/kern/kern_sx.c

624

atomic_set_ptr(&sx->sx_lock, SX_LOCK_RECURSED);

sys/kern/kern_sx.c

625

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

626

CTR2(KTR_LOCK, "%s: %p recursing", __func__, sx);

sys/kern/kern_sx.c

630

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

632

sx->lock_object.lo_name, (void *)sx->sx_lock, file, line);

sys/kern/kern_sx.c

643

lock_profile_obtain_lock_failed(&sx->lock_object, false, &contested,

sys/kern/kern_sx.c

650

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

654

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid))

sys/kern/kern_sx.c

666

if (atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid))

sys/kern/kern_sx.c

682

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

684

__func__, sx, owner);

sys/kern/kern_sx.c

687

sx->lock_object.lo_name);

sys/kern/kern_sx.c

690

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

706

if (!atomic_fcmpset_ptr(&sx->sx_lock, &x,

sys/kern/kern_sx.c

717

sx->lock_object.lo_name);

sys/kern/kern_sx.c

721

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

740

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

741

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

749

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

765

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

771

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

790

if (!atomic_fcmpset_acq_ptr(&sx->sx_lock, &x, tid | setx))

sys/kern/kern_sx.c

792

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

794

__func__, sx);

sys/kern/kern_sx.c

810

if (!atomic_fcmpset_ptr(&sx->sx_lock, &x,

sys/kern/kern_sx.c

824

if (!atomic_fcmpset_ptr(&sx->sx_lock, &x,

sys/kern/kern_sx.c

828

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

830

__func__, sx);

sys/kern/kern_sx.c

841

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

843

__func__, sx);

sys/kern/kern_sx.c

846

sleep_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

848

sleepq_add(&sx->lock_object, NULL, sx->lock_object.lo_name,

sys/kern/kern_sx.c

856

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

858

sleepq_wait(&sx->lock_object, 0);

sys/kern/kern_sx.c

860

error = sleepq_wait_sig(&sx->lock_object, 0);

sys/kern/kern_sx.c

861

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

863

sleep_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

867

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

870

__func__, sx);

sys/kern/kern_sx.c

873

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

875

__func__, sx);

sys/kern/kern_sx.c

876

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

878

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

891

all_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

893

LOCKSTAT_RECORD4(sx__block, sx, sleep_time,

sys/kern/kern_sx.c

897

LOCKSTAT_RECORD4(sx__spin, sx, all_time - sleep_time,

sys/kern/kern_sx.c

903

LOCKSTAT_PROFILE_OBTAIN_RWLOCK_SUCCESS(sx__acquire, sx,

sys/kern/kern_sx.c

915

_sx_xunlock_hard(struct sx *sx, uintptr_t x LOCK_FILE_LINE_ARG_DEF)

sys/kern/kern_sx.c

926

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

932

if ((--sx->sx_recurse) == 0)

sys/kern/kern_sx.c

933

atomic_clear_ptr(&sx->sx_lock, SX_LOCK_RECURSED);

sys/kern/kern_sx.c

934

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

935

CTR2(KTR_LOCK, "%s: %p unrecursing", __func__, sx);

sys/kern/kern_sx.c

939

LOCKSTAT_PROFILE_RELEASE_RWLOCK(sx__release, sx, LOCKSTAT_WRITER);

sys/kern/kern_sx.c

941

atomic_cmpset_rel_ptr(&sx->sx_lock, tid, SX_LOCK_UNLOCKED))

sys/kern/kern_sx.c

944

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

945

CTR2(KTR_LOCK, "%s: %p contested", __func__, sx);

sys/kern/kern_sx.c

947

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

948

x = SX_READ_VALUE(sx);

sys/kern/kern_sx.c

963

sleepq_sleepcnt(&sx->lock_object, SQ_EXCLUSIVE_QUEUE) != 0) {

sys/kern/kern_sx.c

967

atomic_store_rel_ptr(&sx->sx_lock, setx);

sys/kern/kern_sx.c

970

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

972

__func__, sx, queue == SQ_SHARED_QUEUE ? "shared" :

sys/kern/kern_sx.c

975

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0, queue);

sys/kern/kern_sx.c

976

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

992

__sx_slock_try(struct sx *sx, struct thread *td, uintptr_t *xp, bool fp

sys/kern/kern_sysctl.c

102

static struct sx __exclusive_cache_line sysctlmemlock;

sys/kern/kern_sysctl.c

103

static struct sx sysctlstringlock;

sys/kern/kern_vnodedumper.c

54

static struct sx livedump_sx;

sys/kern/subr_epoch.c

144

static struct sx epoch_sx;

sys/kern/subr_epoch.c

85

struct sx e_drain_sx;

sys/kern/subr_pcpu.c

75

static struct sx dpcpu_lock;

sys/kern/subr_rtc.c

125

static struct sx rtc_list_lock;

sys/kern/sysv_shm.c

201

static struct sx sysvshmsx;

sys/kern/tty.c

77

static struct sx tty_list_sx;

sys/kern/uipc_ktls.c

108

static struct sx ktls_init_lock;

sys/kern/uipc_mqueue.c

120

struct sx mi_lock;

sys/kern/uipc_sem.c

104

static struct sx ksem_dict_lock;

sys/kern/uipc_shm.c

115

static struct sx shm_dict_lock;

sys/kern/uipc_socket.c

328

static struct sx splice_init_lock;

sys/kern/uipc_socket.c

4874

soiolock(struct socket *so, struct sx *sx, int flags)

sys/kern/uipc_socket.c

4883

sx_xlock(sx);

sys/kern/uipc_socket.c

4885

error = sx_xlock_sig(sx);

sys/kern/uipc_socket.c

4889

} else if (!sx_try_xlock(sx)) {

sys/kern/uipc_socket.c

4894

sx_xunlock(sx);

sys/kern/uipc_socket.c

4901

soiounlock(struct sx *sx)

sys/kern/uipc_socket.c

4903

sx_xunlock(sx);

sys/kern/vfs_init.c

64

struct sx vfsconf_sx;

sys/libkern/iconv.c

50

static struct sx iconv_lock;

sys/net/bpf.c

226

static struct sx bpf_sx; /* bpf global lock */

sys/net/dummymbuf.c

64

VNET_DEFINE_STATIC(struct sx, dmb_rules_lock);

sys/net/if.c

239

static struct sx ifdescr_sx;

sys/net/if.c

339

struct sx ifnet_sxlock;

sys/net/if.c

342

struct sx ifnet_detach_sxlock;

sys/net/if.h

675

extern struct sx ifnet_detach_sxlock;

sys/net/if_bridge.c

287

struct sx sc_sx;

sys/net/if_bridge.c

308

VNET_DEFINE_STATIC(struct sx, bridge_list_sx);

sys/net/if_gif.c

98

static struct sx gif_ioctl_sx;

sys/net/if_gre.c

107

static struct sx gre_ioctl_sx;

sys/net/if_ipsec.c

159

static struct sx ipsec_ioctl_sx;

sys/net/if_lagg.h

235

struct sx sc_sx;

sys/net/if_me.c

106

static struct sx me_ioctl_sx;

sys/net/if_tuntap.c

198

static struct sx tun_ioctl_sx;

sys/net/if_var.h

490

extern struct sx ifnet_sxlock;

sys/net/if_vlan.c

243

static struct sx _VLAN_SX_ID;

sys/net/if_vxlan.c

83

struct sx vxlan_sx;

sys/net/iflib.c

170

struct sx ifc_ctx_sx;

sys/net/iflib.c

6442

struct sx *

sys/net/iflib.h

495

struct sx *iflib_ctx_lock_get(if_ctx_t);

sys/net/pfvar.h

440

extern struct sx pf_config_lock;

sys/net/pfvar.h

474

extern struct sx pf_end_lock;

sys/net/route/route_tables.c

76

VNET_DEFINE_STATIC(struct sx, rtables_lock);

sys/net/vnet.c

201

struct sx vnet_sysinit_sxlock;

sys/net/vnet.c

218

static struct sx vnet_data_free_lock;

sys/net/vnet.c

91

struct sx vnet_sxlock;

sys/net/vnet.h

259

extern struct sx vnet_sxlock;

sys/netinet/in.c

126

static struct sx in_control_sx;

sys/netinet/in_mcast.c

112

struct sx in_multi_sx;

sys/netinet/in_var.h

368

extern struct sx in_multi_sx;

sys/netinet/ip_carp.c

353

static struct sx carp_sx;

sys/netinet/ip_mroute.c

142

static struct sx __exclusive_cache_line mrouter_teardown;

sys/netinet/netdump/netdump_client.c

122

static struct sx nd_conf_lk;

sys/netinet/tcp_subr.c

2702

static struct sx ktlslist_lock;

sys/netinet/tcp_subr.c

771

static struct sx tcpoudp_lock;

sys/netinet6/in6.c

183

static struct sx in6_control_sx;

sys/netinet6/in6_mcast.c

119

struct sx in6_multi_sx;

sys/netinet6/in6_src.c

114

static struct sx addrsel_sxlock;

sys/netinet6/in6_var.h

781

extern struct sx in6_multi_sx;

sys/netinet6/ip6_mroute.c

172

static struct sx mrouter6_mtx;

sys/netipsec/key.c

239

static struct sx spi_alloc_lock;

sys/netlink/netlink_generic.c

350

static struct sx sx_lock;

sys/netlink/route/iface.c

79

static struct sx rtnl_cloner_lock;

sys/netpfil/ipfw/ip_fw_private.h

331

struct sx uh_lock; /* lock for upper half */

sys/netpfil/pf/pf.c

294

struct sx pf_config_lock;

sys/netpfil/pf/pf_ioctl.c

295

VNET_DEFINE_STATIC(struct sx, pf_ioctl_lock);

sys/netpfil/pf/pf_ioctl.c

297

struct sx pf_end_lock;

sys/netsmb/smb_conn.h

196

struct sx co_interlock;

sys/netsmb/smb_dev.c

67

struct sx smb_lock;

sys/netsmb/smb_dev.h

170

extern struct sx smb_lock;

sys/rpc/auth_unix.c

103

static struct sx auth_unix_lock;

sys/rpc/rpcsec_gss/rpcsec_gss.c

155

static struct sx rpc_gss_lock;

sys/rpc/rpcsec_gss/svc_rpcsec_gss.c

137

struct sx cl_lock;

sys/rpc/rpcsec_gss/svc_rpcsec_gss.c

96

struct sx svc_rpc_gss_lock;

sys/rpc/svc.h

129

struct sx xp_lock;

sys/security/audit/audit_bsm_db.c

101

static struct sx evnamemap_lock;

sys/security/audit/audit_pipe.c

128

struct sx ap_sx;

sys/security/audit/audit_worker.c

97

static struct sx audit_worker_lock;

sys/sys/_rmlock.h

61

struct sx _rm_lock_sx;

sys/sys/filedesc.h

120

struct sx fd_sx; /* protects members of this struct */

sys/sys/jail.h

401

extern struct sx allprison_lock;

sys/sys/lockf.h

114

struct sx ls_lock;

sys/sys/module.h

216

extern struct sx modules_sx;

sys/sys/mount.h

1075

extern struct sx vfsconf_sx;

sys/sys/pmckern.h

183

extern struct sx pmc_sx;

sys/sys/proc.h

1072

extern struct sx *pidhashtbl_lock;

sys/sys/proc.h

1080

extern struct sx allproc_lock;

sys/sys/proc.h

1082

extern struct sx proctree_lock;

sys/sys/proc.h

113

struct sx pg_killsx; /* Mutual exclusion between group member

sys/sys/socketvar.h

152

struct sx so_snd_sx __aligned(CACHE_LINE_SIZE);

sys/sys/socketvar.h

155

struct sx so_rcv_sx __aligned(CACHE_LINE_SIZE);

sys/sys/socketvar.h

580

int soiolock(struct socket *so, struct sx *sx, int flags);

sys/sys/socketvar.h

581

void soiounlock(struct sx *sx);

sys/sys/sx.h

103

#define sx_init(sx, desc) sx_init_flags((sx), (desc), 0)

sys/sys/sx.h

104

void sx_init_flags(struct sx *sx, const char *description, int opts);

sys/sys/sx.h

105

void sx_destroy(struct sx *sx);

sys/sys/sx.h

106

int sx_try_slock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

107

int sx_try_slock_(struct sx *sx, const char *file, int line);

sys/sys/sx.h

108

int sx_try_xlock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

109

int sx_try_xlock_(struct sx *sx, const char *file, int line);

sys/sys/sx.h

110

int sx_try_upgrade_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

111

int sx_try_upgrade_(struct sx *sx, const char *file, int line);

sys/sys/sx.h

112

void sx_downgrade_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

113

void sx_downgrade_(struct sx *sx, const char *file, int line);

sys/sys/sx.h

114

int _sx_slock_int(struct sx *sx, int opts LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

115

int _sx_slock(struct sx *sx, int opts, const char *file, int line);

sys/sys/sx.h

116

int _sx_xlock(struct sx *sx, int opts, const char *file, int line);

sys/sys/sx.h

117

void _sx_sunlock_int(struct sx *sx LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

118

void _sx_sunlock(struct sx *sx, const char *file, int line);

sys/sys/sx.h

119

void _sx_xunlock(struct sx *sx, const char *file, int line);

sys/sys/sx.h

120

int _sx_xlock_hard(struct sx *sx, uintptr_t x, int opts LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

121

void _sx_xunlock_hard(struct sx *sx, uintptr_t x LOCK_FILE_LINE_ARG_DEF);

sys/sys/sx.h

123

void _sx_assert(const struct sx *sx, int what, const char *file, int line);

sys/sys/sx.h

130

struct sx *sa_sx;

sys/sys/sx.h

157

__sx_xlock(struct sx *sx, struct thread *td, int opts, const char *file,

sys/sys/sx.h

165

!atomic_fcmpset_acq_ptr(&sx->sx_lock, &v, tid)))

sys/sys/sx.h

166

error = _sx_xlock_hard(sx, v, opts);

sys/sys/sx.h

173

__sx_xunlock(struct sx *sx, struct thread *td, const char *file, int line)

sys/sys/sx.h

178

!atomic_fcmpset_rel_ptr(&sx->sx_lock, &x, SX_LOCK_UNLOCKED)))

sys/sys/sx.h

179

_sx_xunlock_hard(sx, x);

sys/sys/sx.h

190

#define sx_xlock_(sx, file, line) \

sys/sys/sx.h

191

(void)_sx_xlock((sx), 0, (file), (line))

sys/sys/sx.h

192

#define sx_xlock_sig_(sx, file, line) \

sys/sys/sx.h

193

_sx_xlock((sx), SX_INTERRUPTIBLE, (file), (line))

sys/sys/sx.h

194

#define sx_xunlock_(sx, file, line) \

sys/sys/sx.h

195

_sx_xunlock((sx), (file), (line))

sys/sys/sx.h

197

#define sx_xlock_(sx, file, line) \

sys/sys/sx.h

198

(void)__sx_xlock((sx), curthread, 0, (file), (line))

sys/sys/sx.h

199

#define sx_xlock_sig_(sx, file, line) \

sys/sys/sx.h

200

__sx_xlock((sx), curthread, SX_INTERRUPTIBLE, (file), (line))

sys/sys/sx.h

201

#define sx_xunlock_(sx, file, line) \

sys/sys/sx.h

202

__sx_xunlock((sx), curthread, (file), (line))

sys/sys/sx.h

205

#define sx_slock_(sx, file, line) \

sys/sys/sx.h

206

(void)_sx_slock((sx), 0, (file), (line))

sys/sys/sx.h

207

#define sx_slock_sig_(sx, file, line) \

sys/sys/sx.h

208

_sx_slock((sx), SX_INTERRUPTIBLE, (file) , (line))

sys/sys/sx.h

209

#define sx_sunlock_(sx, file, line) \

sys/sys/sx.h

210

_sx_sunlock((sx), (file), (line))

sys/sys/sx.h

211

#define sx_try_slock(sx) sx_try_slock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

212

#define sx_try_xlock(sx) sx_try_xlock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

213

#define sx_try_upgrade(sx) sx_try_upgrade_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

214

#define sx_downgrade(sx) sx_downgrade_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

216

#define sx_slock_(sx, file, line) \

sys/sys/sx.h

217

(void)_sx_slock_int((sx), 0)

sys/sys/sx.h

218

#define sx_slock_sig_(sx, file, line) \

sys/sys/sx.h

219

_sx_slock_int((sx), SX_INTERRUPTIBLE)

sys/sys/sx.h

220

#define sx_sunlock_(sx, file, line) \

sys/sys/sx.h

221

_sx_sunlock_int((sx))

sys/sys/sx.h

222

#define sx_try_slock(sx) sx_try_slock_int((sx))

sys/sys/sx.h

223

#define sx_try_xlock(sx) sx_try_xlock_int((sx))

sys/sys/sx.h

224

#define sx_try_upgrade(sx) sx_try_upgrade_int((sx))

sys/sys/sx.h

225

#define sx_downgrade(sx) sx_downgrade_int((sx))

sys/sys/sx.h

228

#define sx_assert_(sx, what, file, line) \

sys/sys/sx.h

229

_sx_assert((sx), (what), (file), (line))

sys/sys/sx.h

231

#define sx_assert_(sx, what, file, line) (void)0

sys/sys/sx.h

234

#define sx_xlock(sx) sx_xlock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

235

#define sx_xlock_sig(sx) sx_xlock_sig_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

236

#define sx_xunlock(sx) sx_xunlock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

237

#define sx_slock(sx) sx_slock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

238

#define sx_slock_sig(sx) sx_slock_sig_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

239

#define sx_sunlock(sx) sx_sunlock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

240

#define sx_assert(sx, what) sx_assert_((sx), (what), __FILE__, __LINE__)

sys/sys/sx.h

246

#define sx_xholder(sx) \

sys/sys/sx.h

247

((sx)->sx_lock & SX_LOCK_SHARED ? NULL : \

sys/sys/sx.h

248

(struct thread *)SX_OWNER((sx)->sx_lock))

sys/sys/sx.h

250

#define sx_xlocked(sx) \

sys/sys/sx.h

251

(((sx)->sx_lock & ~(SX_LOCK_FLAGMASK & ~SX_LOCK_SHARED)) == \

sys/sys/sx.h

254

#define sx_unlock_(sx, file, line) __extension__ ({ \

sys/sys/sx.h

255

if (sx_xlocked(sx)) \

sys/sys/sx.h

256

sx_xunlock_(sx, file, line); \

sys/sys/sx.h

258

sx_sunlock_(sx, file, line); \

sys/sys/sx.h

262

#define sx_unlock(sx) sx_unlock_((sx), LOCK_FILE, LOCK_LINE)

sys/sys/sx.h

264

#define sx_sleep(chan, sx, pri, wmesg, timo) \

sys/sys/sx.h

265

_sleep((chan), &(sx)->lock_object, (pri), (wmesg), \

sys/sys/sx.h

312

sx_init_flags(struct sx *sx, const char *description, int opts)

sys/sys/sx.h

318

sx_destroy(struct sx *sx)

sys/sys/sx.h

93

#define SX_READ_VALUE(sx) ((sx)->sx_lock)

sys/ufs/ffs/ffs_suspend.c

66

static struct sx ffs_susp_lock;

sys/ufs/ufs/dirhash.h

86

struct sx dh_lock; /* protects all fields except list & score */

sys/ufs/ufs/extattr.h

120

struct sx uepm_lock;

sys/vm/swap_pager.c

162

static struct sx swdev_syscall_lock; /* serialize swap(on|off) */

sys/vm/swap_pager.c

412

static struct sx sw_alloc_sx;

sys/vm/uma_core.c

175

static struct sx uma_reclaim_lock;

sys/vm/vm_map.h

206

struct sx lock; /* Lock for map data */

sys/x86/iommu/intel_idpgtbl.c

97

static struct sx idpgtbl_lock;

sys/x86/x86/intr_machdep.c

86

static struct sx intrsrc_lock;

sys/xen/xenbus/xenbusb.h

138

struct sx xd_lock;