arch/powerpc/include/asm/kvm_ppc.h

236

extern int kvmppc_xics_set_xive(struct kvm *kvm, u32 irq, u32 server,

arch/powerpc/include/asm/kvm_ppc.h

238

extern int kvmppc_xics_get_xive(struct kvm *kvm, u32 irq, u32 *server,

arch/powerpc/include/asm/kvm_ppc.h

721

extern int kvmppc_xive_set_xive(struct kvm *kvm, u32 irq, u32 server,

arch/powerpc/include/asm/kvm_ppc.h

723

extern int kvmppc_xive_get_xive(struct kvm *kvm, u32 irq, u32 *server,

arch/powerpc/include/asm/kvm_ppc.h

759

static inline int kvmppc_xive_set_xive(struct kvm *kvm, u32 irq, u32 server,

arch/powerpc/include/asm/kvm_ppc.h

761

static inline int kvmppc_xive_get_xive(struct kvm *kvm, u32 irq, u32 *server,

arch/powerpc/include/asm/opal.h

77

int64_t opal_set_xive(uint32_t isn, uint16_t server, uint8_t priority);

arch/powerpc/include/asm/opal.h

78

int64_t opal_get_xive(uint32_t isn, __be16 *server, uint8_t *priority);

arch/powerpc/kvm/book3s_hv_rm_xics.c

314

if (!icp || state->server != icp->server_num) {

arch/powerpc/kvm/book3s_hv_rm_xics.c

315

icp = kvmppc_xics_find_server(xics->kvm, state->server);

arch/powerpc/kvm/book3s_hv_rm_xics.c

526

int xics_rm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,

arch/powerpc/kvm/book3s_hv_rm_xics.c

539

local = this_icp->server_num == server;

arch/powerpc/kvm/book3s_hv_rm_xics.c

543

icp = kvmppc_xics_find_server(vcpu->kvm, server);

arch/powerpc/kvm/book3s_rtas.c

21

u32 irq, server, priority;

arch/powerpc/kvm/book3s_rtas.c

30

server = be32_to_cpu(args->args[1]);

arch/powerpc/kvm/book3s_rtas.c

34

rc = kvmppc_xive_set_xive(vcpu->kvm, irq, server, priority);

arch/powerpc/kvm/book3s_rtas.c

36

rc = kvmppc_xics_set_xive(vcpu->kvm, irq, server, priority);

arch/powerpc/kvm/book3s_rtas.c

45

u32 irq, server, priority;

arch/powerpc/kvm/book3s_rtas.c

55

server = priority = 0;

arch/powerpc/kvm/book3s_rtas.c

57

rc = kvmppc_xive_get_xive(vcpu->kvm, irq, &server, &priority);

arch/powerpc/kvm/book3s_rtas.c

59

rc = kvmppc_xics_get_xive(vcpu->kvm, irq, &server, &priority);

arch/powerpc/kvm/book3s_rtas.c

65

args->rets[1] = cpu_to_be32(server);

arch/powerpc/kvm/book3s_xics.c

1004

irq->number, irq->server, irq->priority,

arch/powerpc/kvm/book3s_xics.c

1195

val = irqp->server;

arch/powerpc/kvm/book3s_xics.c

1234

u32 server;

arch/powerpc/kvm/book3s_xics.c

1250

server = val & KVM_XICS_DESTINATION_MASK;

arch/powerpc/kvm/book3s_xics.c

1253

kvmppc_xics_find_server(xics->kvm, server) == NULL)

arch/powerpc/kvm/book3s_xics.c

1258

irqp->server = server;

arch/powerpc/kvm/book3s_xics.c

142

u32 server, u32 priority, u32 saved_priority)

arch/powerpc/kvm/book3s_xics.c

150

state->server = server;

arch/powerpc/kvm/book3s_xics.c

166

int kvmppc_xics_set_xive(struct kvm *kvm, u32 irq, u32 server, u32 priority)

arch/powerpc/kvm/book3s_xics.c

182

icp = kvmppc_xics_find_server(kvm, server);

arch/powerpc/kvm/book3s_xics.c

187

irq, server, priority,

arch/powerpc/kvm/book3s_xics.c

190

if (write_xive(xics, ics, state, server, priority, priority))

arch/powerpc/kvm/book3s_xics.c

196

int kvmppc_xics_get_xive(struct kvm *kvm, u32 irq, u32 *server, u32 *priority)

arch/powerpc/kvm/book3s_xics.c

214

*server = state->server;

arch/powerpc/kvm/book3s_xics.c

238

icp = kvmppc_xics_find_server(kvm, state->server);

arch/powerpc/kvm/book3s_xics.c

242

if (write_xive(xics, ics, state, state->server, state->saved_priority,

arch/powerpc/kvm/book3s_xics.c

264

write_xive(xics, ics, state, state->server, MASKED, state->priority);

arch/powerpc/kvm/book3s_xics.c

415

if (!icp || state->server != icp->server_num) {

arch/powerpc/kvm/book3s_xics.c

416

icp = kvmppc_xics_find_server(xics->kvm, state->server);

arch/powerpc/kvm/book3s_xics.c

419

new_irq, state->server);

arch/powerpc/kvm/book3s_xics.c

619

static noinline int kvmppc_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,

arch/powerpc/kvm/book3s_xics.c

630

vcpu->vcpu_id, server, mfrr);

arch/powerpc/kvm/book3s_xics.c

633

local = icp->server_num == server;

arch/powerpc/kvm/book3s_xics.c

635

icp = kvmppc_xics_find_server(vcpu->kvm, server);

arch/powerpc/kvm/book3s_xics.c

704

static int kvmppc_h_ipoll(struct kvm_vcpu *vcpu, unsigned long server)

arch/powerpc/kvm/book3s_xics.c

710

if (icp->server_num != server) {

arch/powerpc/kvm/book3s_xics.c

711

icp = kvmppc_xics_find_server(vcpu->kvm, server);

arch/powerpc/kvm/book3s_xics.h

147

extern int xics_rm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,

arch/powerpc/kvm/book3s_xics.h

38

u32 server;

arch/powerpc/kvm/book3s_xive.c

1004

static void xive_inc_q_pending(struct kvm *kvm, u32 server, u8 prio)

arch/powerpc/kvm/book3s_xive.c

1011

vcpu = kvmppc_xive_find_server(kvm, server);

arch/powerpc/kvm/book3s_xive.c

1013

pr_warn("%s: Can't find server %d\n", __func__, server);

arch/powerpc/kvm/book3s_xive.c

1044

int kvmppc_xive_select_target(struct kvm *kvm, u32 *server, u8 prio)

arch/powerpc/kvm/book3s_xive.c

1051

vcpu = kvmppc_xive_find_server(kvm, *server);

arch/powerpc/kvm/book3s_xive.c

1053

pr_devel("Can't find server %d\n", *server);

arch/powerpc/kvm/book3s_xive.c

1057

pr_devel("Finding irq target on 0x%x/%d...\n", *server, prio);

arch/powerpc/kvm/book3s_xive.c

1072

*server = vcpu->arch.xive_vcpu->server_num;

arch/powerpc/kvm/book3s_xive.c

1073

pr_devel(" found on 0x%x/%d\n", *server, prio);

arch/powerpc/kvm/book3s_xive.c

1184

u32 server, u8 prio)

arch/powerpc/kvm/book3s_xive.c

1195

rc = kvmppc_xive_select_target(kvm, &server, prio);

arch/powerpc/kvm/book3s_xive.c

1217

state->act_server = server;

arch/powerpc/kvm/book3s_xive.c

1223

kvmppc_xive_vp(xive, server),

arch/powerpc/kvm/book3s_xive.c

1267

int kvmppc_xive_set_xive(struct kvm *kvm, u32 irq, u32 server,

arch/powerpc/kvm/book3s_xive.c

1281

irq, server, priority);

arch/powerpc/kvm/book3s_xive.c

1347

(state->act_server != server ||

arch/powerpc/kvm/book3s_xive.c

1349

rc = xive_target_interrupt(kvm, state, server, new_act_prio);

arch/powerpc/kvm/book3s_xive.c

1368

int kvmppc_xive_get_xive(struct kvm *kvm, u32 irq, u32 *server,

arch/powerpc/kvm/book3s_xive.c

1384

*server = state->act_server;

arch/powerpc/kvm/book3s_xive.c

2332

u32 server;

arch/powerpc/kvm/book3s_xive.c

2358

server = val & KVM_XICS_DESTINATION_MASK;

arch/powerpc/kvm/book3s_xive.c

2362

val, server, guest_prio);

arch/powerpc/kvm/book3s_xive.c

2416

server, act_prio);

arch/powerpc/kvm/book3s_xive.c

336

static unsigned long xive_vm_h_ipoll(struct kvm_vcpu *vcpu, unsigned long server)

arch/powerpc/kvm/book3s_xive.c

342

pr_devel("H_IPOLL(server=%ld)\n", server);

arch/powerpc/kvm/book3s_xive.c

347

if (xc->server_num != server) {

arch/powerpc/kvm/book3s_xive.c

348

vcpu = kvmppc_xive_find_server(vcpu->kvm, server);

arch/powerpc/kvm/book3s_xive.c

620

static int xive_vm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,

arch/powerpc/kvm/book3s_xive.c

625

pr_devel("H_IPI(server=%08lx,mfrr=%ld)\n", server, mfrr);

arch/powerpc/kvm/book3s_xive.c

630

vcpu = kvmppc_xive_find_server(vcpu->kvm, server);

arch/powerpc/kvm/book3s_xive.h

235

static inline u32 kvmppc_xive_vp(struct kvmppc_xive *xive, u32 server)

arch/powerpc/kvm/book3s_xive.h

237

return xive->vp_base + kvmppc_pack_vcpu_id(xive->kvm, server);

arch/powerpc/kvm/book3s_xive.h

298

int kvmppc_xive_select_target(struct kvm *kvm, u32 *server, u8 prio);

arch/powerpc/kvm/book3s_xive_native.c

419

u32 server, u8 priority, bool masked,

arch/powerpc/kvm/book3s_xive_native.c

428

if (state->act_server == server && state->act_priority == priority &&

arch/powerpc/kvm/book3s_xive_native.c

433

priority, server, masked, state->act_server,

arch/powerpc/kvm/book3s_xive_native.c

439

rc = kvmppc_xive_select_target(kvm, &server, priority);

arch/powerpc/kvm/book3s_xive_native.c

444

state->act_server = server;

arch/powerpc/kvm/book3s_xive_native.c

448

kvmppc_xive_vp(xive, server),

arch/powerpc/kvm/book3s_xive_native.c

471

u32 server;

arch/powerpc/kvm/book3s_xive_native.c

492

server = (kvm_cfg & KVM_XIVE_SOURCE_SERVER_MASK) >>

arch/powerpc/kvm/book3s_xive_native.c

501

priority, server);

arch/powerpc/kvm/book3s_xive_native.c

505

return kvmppc_xive_native_update_source_config(xive, sb, state, server,

arch/powerpc/kvm/book3s_xive_native.c

566

u32 server;

arch/powerpc/kvm/book3s_xive_native.c

582

server = (eq_idx & KVM_XIVE_EQ_SERVER_MASK) >>

arch/powerpc/kvm/book3s_xive_native.c

588

vcpu = kvmppc_xive_find_server(kvm, server);

arch/powerpc/kvm/book3s_xive_native.c

590

pr_err("Can't find server %d\n", server);

arch/powerpc/kvm/book3s_xive_native.c

597

priority, server);

arch/powerpc/kvm/book3s_xive_native.c

603

__func__, server, priority, kvm_eq.flags,

arch/powerpc/kvm/book3s_xive_native.c

715

u32 server;

arch/powerpc/kvm/book3s_xive_native.c

730

server = (eq_idx & KVM_XIVE_EQ_SERVER_MASK) >>

arch/powerpc/kvm/book3s_xive_native.c

733

vcpu = kvmppc_xive_find_server(kvm, server);

arch/powerpc/kvm/book3s_xive_native.c

735

pr_err("Can't find server %d\n", server);

arch/powerpc/kvm/book3s_xive_native.c

742

priority, server);

arch/powerpc/kvm/book3s_xive_native.c

770

__func__, server, priority, kvm_eq.flags,

arch/powerpc/sysdev/xics/ics-native.c

103

int server;

arch/powerpc/sysdev/xics/ics-native.c

109

server = xics_get_irq_server(d->irq, cpumask, 1);

arch/powerpc/sysdev/xics/ics-native.c

110

if (server == -1) {

arch/powerpc/sysdev/xics/ics-native.c

117

xive = (xive & 0xff) | (server << 8);

arch/powerpc/sysdev/xics/ics-native.c

50

unsigned int server;

arch/powerpc/sysdev/xics/ics-native.c

57

server = xics_get_irq_server(d->irq, irq_data_get_affinity_mask(d), 0);

arch/powerpc/sysdev/xics/ics-native.c

58

out_be32(ics_native_xive(in, vec), (server << 8) | DEFAULT_PRIORITY);

arch/powerpc/sysdev/xics/ics-opal.c

100

int16_t server;

arch/powerpc/sysdev/xics/ics-opal.c

121

server = ics_opal_mangle_server(wanted_server);

arch/powerpc/sysdev/xics/ics-opal.c

124

d->irq, hw_irq, wanted_server, server);

arch/powerpc/sysdev/xics/ics-opal.c

126

rc = opal_set_xive(hw_irq, server, priority);

arch/powerpc/sysdev/xics/ics-opal.c

130

__func__, d->irq, hw_irq, server, rc);

arch/powerpc/sysdev/xics/ics-opal.c

155

__be16 server;

arch/powerpc/sysdev/xics/ics-opal.c

162

rc = opal_get_xive(hw_irq, &server, &priority);

arch/powerpc/sysdev/xics/ics-opal.c

172

__be16 server;

arch/powerpc/sysdev/xics/ics-opal.c

176

rc = opal_get_xive(vec, &server, &priority);

arch/powerpc/sysdev/xics/ics-opal.c

186

__be16 server;

arch/powerpc/sysdev/xics/ics-opal.c

190

rc = opal_get_xive(vec, &server, &priority);

arch/powerpc/sysdev/xics/ics-opal.c

193

return ics_opal_unmangle_server(be16_to_cpu(server));

arch/powerpc/sysdev/xics/ics-opal.c

29

static int ics_opal_mangle_server(int server)

arch/powerpc/sysdev/xics/ics-opal.c

32

return server << 2;

arch/powerpc/sysdev/xics/ics-opal.c

35

static int ics_opal_unmangle_server(int server)

arch/powerpc/sysdev/xics/ics-opal.c

38

return server >> 2;

arch/powerpc/sysdev/xics/ics-opal.c

45

int server;

arch/powerpc/sysdev/xics/ics-opal.c

52

server = xics_get_irq_server(d->irq, irq_data_get_affinity_mask(d), 0);

arch/powerpc/sysdev/xics/ics-opal.c

53

server = ics_opal_mangle_server(server);

arch/powerpc/sysdev/xics/ics-opal.c

55

rc = opal_set_xive(hw_irq, server, DEFAULT_PRIORITY);

arch/powerpc/sysdev/xics/ics-opal.c

59

__func__, d->irq, hw_irq, server, rc);

arch/powerpc/sysdev/xics/ics-opal.c

70

int server = ics_opal_mangle_server(xics_default_server);

arch/powerpc/sysdev/xics/ics-opal.c

77

rc = opal_set_xive(hw_irq, server, 0xff);

arch/powerpc/sysdev/xics/ics-rtas.c

30

int server;

arch/powerpc/sysdev/xics/ics-rtas.c

37

server = xics_get_irq_server(d->irq, irq_data_get_affinity_mask(d), 0);

arch/powerpc/sysdev/xics/ics-rtas.c

39

call_status = rtas_call(ibm_set_xive, 3, 1, NULL, hw_irq, server,

arch/powerpc/sysdev/xics/ics-rtas.c

44

__func__, hw_irq, server, call_status);

arch/powerpc/sysdev/xics/xics-common.c

200

long server;

arch/powerpc/sysdev/xics/xics-common.c

225

server = xics_ics->get_server(xics_ics, irq);

arch/powerpc/sysdev/xics/xics-common.c

226

if (server < 0) {

arch/powerpc/sysdev/xics/xics-common.c

236

if (server != hw_cpu)

arch/powerpc/sysdev/xics/xics-common.c

286

int server = cpumask_first_and(cpu_online_mask, cpumask);

arch/powerpc/sysdev/xics/xics-common.c

288

if (server < nr_cpu_ids)

arch/powerpc/sysdev/xics/xics-common.c

289

return get_hard_smp_processor_id(server);

drivers/char/tpm/eventlog/acpi.c

124

len = buff->server.log_max_len;

drivers/char/tpm/eventlog/acpi.c

125

start = buff->server.log_start_addr;

drivers/char/tpm/eventlog/acpi.c

41

} server;

drivers/s390/block/dasd_alias.c

101

server = kzalloc_obj(*server);

drivers/s390/block/dasd_alias.c

102

if (!server)

drivers/s390/block/dasd_alias.c

104

memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));

drivers/s390/block/dasd_alias.c

105

memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));

drivers/s390/block/dasd_alias.c

106

INIT_LIST_HEAD(&server->server);

drivers/s390/block/dasd_alias.c

107

INIT_LIST_HEAD(&server->lculist);

drivers/s390/block/dasd_alias.c

108

return server;

drivers/s390/block/dasd_alias.c

111

static void _free_server(struct alias_server *server)

drivers/s390/block/dasd_alias.c

113

kfree(server);

drivers/s390/block/dasd_alias.c

182

struct alias_server *server, *newserver;

drivers/s390/block/dasd_alias.c

188

server = _find_server(&uid);

drivers/s390/block/dasd_alias.c

189

if (!server) {

drivers/s390/block/dasd_alias.c

195

server = _find_server(&uid);

drivers/s390/block/dasd_alias.c

196

if (!server) {

drivers/s390/block/dasd_alias.c

197

list_add(&newserver->server, &aliastree.serverlist);

drivers/s390/block/dasd_alias.c

198

server = newserver;

drivers/s390/block/dasd_alias.c

205

lcu = _find_lcu(server, &uid);

drivers/s390/block/dasd_alias.c

212

lcu = _find_lcu(server, &uid);

drivers/s390/block/dasd_alias.c

214

list_add(&newlcu->lcu, &server->lculist);

drivers/s390/block/dasd_alias.c

240

struct alias_server *server;

drivers/s390/block/dasd_alias.c

289

server = _find_server(&uid);

drivers/s390/block/dasd_alias.c

290

if (server && list_empty(&server->lculist)) {

drivers/s390/block/dasd_alias.c

291

list_del(&server->server);

drivers/s390/block/dasd_alias.c

292

_free_server(server);

drivers/s390/block/dasd_alias.c

48

list_for_each_entry(pos, &aliastree.serverlist, server) {

drivers/s390/block/dasd_alias.c

58

static struct alias_lcu *_find_lcu(struct alias_server *server,

drivers/s390/block/dasd_alias.c

62

list_for_each_entry(pos, &server->lculist, lcu) {

drivers/s390/block/dasd_alias.c

99

struct alias_server *server;

drivers/s390/block/dasd_eckd.h

621

struct list_head server;

drivers/scsi/iscsi_boot_sysfs.c

246

iscsi_boot_rd_attr(ini_isns, isns-server, ISCSI_BOOT_INI_ISNS_SERVER);

drivers/scsi/iscsi_boot_sysfs.c

247

iscsi_boot_rd_attr(ini_slp, slp-server, ISCSI_BOOT_INI_SLP_SERVER);

drivers/scsi/iscsi_boot_sysfs.c

248

iscsi_boot_rd_attr(ini_primary_radius, pri-radius-server,

drivers/scsi/iscsi_boot_sysfs.c

250

iscsi_boot_rd_attr(ini_secondary_radius, sec-radius-server,

drivers/soc/qcom/qmi_interface.c

147

le32_to_cpu(pkt->server.service),

drivers/soc/qcom/qmi_interface.c

148

le32_to_cpu(pkt->server.instance),

drivers/soc/qcom/qmi_interface.c

149

le32_to_cpu(pkt->server.node),

drivers/soc/qcom/qmi_interface.c

150

le32_to_cpu(pkt->server.port));

drivers/soc/qcom/qmi_interface.c

154

le32_to_cpu(pkt->server.node),

drivers/soc/qcom/qmi_interface.c

155

le32_to_cpu(pkt->server.port));

drivers/soc/qcom/qmi_interface.c

175

pkt.server.service = cpu_to_le32(svc->service);

drivers/soc/qcom/qmi_interface.c

176

pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);

drivers/soc/qcom/qmi_interface.c

238

pkt.server.service = cpu_to_le32(svc->service);

drivers/soc/qcom/qmi_interface.c

239

pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);

drivers/soc/qcom/qmi_interface.c

240

pkt.server.node = cpu_to_le32(qmi->sq.sq_node);

drivers/soc/qcom/qmi_interface.c

241

pkt.server.port = cpu_to_le32(qmi->sq.sq_port);

fs/afs/addr_list.c

145

vllist->servers[0].server = afs_alloc_vlserver("<dummy>", 7, AFS_VL_PORT);

fs/afs/addr_list.c

146

if (!vllist->servers[0].server)

fs/afs/addr_list.c

228

rcu_assign_pointer(vllist->servers[0].server->addresses, alist);

fs/afs/addr_list.c

369

void afs_set_peer_appdata(struct afs_server *server,

fs/afs/addr_list.c

373

unsigned long data = (unsigned long)server;

fs/afs/callback.c

158

static void afs_break_volume_callback(struct afs_server *server,

fs/afs/callback.c

168

if (slist->servers[i].server == server)

fs/afs/callback.c

188

static void afs_break_one_callback(struct afs_server *server,

fs/afs/callback.c

213

static void afs_break_some_callbacks(struct afs_server *server,

fs/afs/callback.c

223

volume = afs_lookup_volume_rcu(server->cell, vid);

fs/afs/callback.c

225

afs_break_volume_callback(server, volume);

fs/afs/callback.c

242

afs_break_one_callback(server, volume, &cbb->fid);

fs/afs/callback.c

256

void afs_break_callbacks(struct afs_server *server, size_t count,

fs/afs/callback.c

259

_enter("%p,%zu,", server, count);

fs/afs/callback.c

261

ASSERT(server != NULL);

fs/afs/callback.c

264

afs_break_some_callbacks(server, callbacks, &count);

fs/afs/callback.c

56

void afs_init_callback_state(struct afs_server *server)

fs/afs/callback.c

60

down_read(&server->cell->vs_lock);

fs/afs/callback.c

62

list_for_each_entry(se, &server->volumes, slink) {

fs/afs/callback.c

71

up_read(&server->cell->vs_lock);

fs/afs/cm_security.c

180

struct afs_server *server)

fs/afs/cm_security.c

186

struct afs_net *net = server->cell->net;

fs/afs/cm_security.c

224

uuidsize = sizeof(server->uuid);

fs/afs/cm_security.c

23

struct afs_server *server);

fs/afs/cm_security.c

273

memcpy(xdr, &server->uuid, 16); /* appdata.acceptorUuid */

fs/afs/cm_security.c

307

memcpy(xdr, &server->uuid, uuidsize);

fs/afs/cm_security.c

329

server->cm_rxgk_appdata.len = adatasize;

fs/afs/cm_security.c

33

struct afs_server *server;

fs/afs/cm_security.c

330

server->cm_rxgk_appdata.data = appdata;

fs/afs/cm_security.c

75

server = (struct afs_server *)peer_data;

fs/afs/cm_security.c

76

if (!server->cm_rxgk_appdata.data) {

fs/afs/cm_security.c

77

mutex_lock(&server->cm_token_lock);

fs/afs/cm_security.c

78

if (!server->cm_rxgk_appdata.data)

fs/afs/cm_security.c

79

afs_create_yfs_cm_token(challenge, server);

fs/afs/cm_security.c

80

mutex_unlock(&server->cm_token_lock);

fs/afs/cm_security.c

82

if (server->cm_rxgk_appdata.data)

fs/afs/cm_security.c

83

appdata = server->cm_rxgk_appdata;

fs/afs/cmservice.c

174

if (call->server) {

fs/afs/cmservice.c

175

trace_afs_server(call->server->debug_id,

fs/afs/cmservice.c

176

refcount_read(&call->server->ref),

fs/afs/cmservice.c

177

atomic_read(&call->server->active),

fs/afs/cmservice.c

179

afs_break_callbacks(call->server, call->count, call->request);

fs/afs/cmservice.c

291

_enter("{%p}", call->server);

fs/afs/cmservice.c

293

if (call->server)

fs/afs/cmservice.c

294

afs_init_callback_state(call->server);

fs/afs/cmservice.c

367

if (memcmp(call->request, &call->server->_uuid, sizeof(call->server->_uuid)) != 0) {

fs/afs/dir.c

746

struct afs_server *server;

fs/afs/dir.c

757

server = slist->servers[i].server;

fs/afs/dir.c

758

if (server == dvnode->cb_server) {

fs/afs/dir.c

759

if (test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags))

fs/afs/file.c

241

if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags))

fs/afs/file.c

249

if (op->call_responded && op->server)

fs/afs/file.c

250

set_bit(AFS_SERVER_FL_RESPONDING, &op->server->flags);

fs/afs/fs_operation.c

286

if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&

fs/afs/fs_operation.c

303

if (op->call_responded && op->server)

fs/afs/fs_operation.c

304

set_bit(AFS_SERVER_FL_RESPONDING, &op->server->flags);

fs/afs/fs_probe.c

105

afs_finished_fs_probe(net, server, estate);

fs/afs/fs_probe.c

107

wake_up_all(&server->probe_wq);

fs/afs/fs_probe.c

115

struct afs_server *server,

fs/afs/fs_probe.c

122

spin_lock(&server->probe_lock);

fs/afs/fs_probe.c

130

spin_unlock(&server->probe_lock);

fs/afs/fs_probe.c

131

return afs_done_one_fs_probe(net, server, estate);

fs/afs/fs_probe.c

143

struct afs_server *server = call->server;

fs/afs/fs_probe.c

148

_enter("%pU,%u", &server->uuid, index);

fs/afs/fs_probe.c

152

spin_lock(&server->probe_lock);

fs/afs/fs_probe.c

196

set_bit(AFS_SERVER_FL_IS_YFS, &server->flags);

fs/afs/fs_probe.c

197

server->service_id = call->service_id;

fs/afs/fs_probe.c

201

clear_bit(AFS_SERVER_FL_IS_YFS, &server->flags);

fs/afs/fs_probe.c

202

server->service_id = call->service_id;

fs/afs/fs_probe.c

206

set_bit(AFS_SERVER_FL_HAS_FS64, &server->flags);

fs/afs/fs_probe.c

208

clear_bit(AFS_SERVER_FL_HAS_FS64, &server->flags);

fs/afs/fs_probe.c

214

server->rtt = rtt_us;

fs/afs/fs_probe.c

221

set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);

fs/afs/fs_probe.c

223

spin_unlock(&server->probe_lock);

fs/afs/fs_probe.c

225

trace_afs_fs_probe(server, false, estate, index, call->error, call->abort_code, rtt_us);

fs/afs/fs_probe.c

227

estate->probe_seq, &server->uuid, index,

fs/afs/fs_probe.c

231

return afs_done_one_fs_probe(call->net, server, estate);

fs/afs/fs_probe.c

238

int afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server,

fs/afs/fs_probe.c

245

_enter("%pU", &server->uuid);

fs/afs/fs_probe.c

252

estate->server_id = server->debug_id;

fs/afs/fs_probe.c

255

write_lock(&server->fs_lock);

fs/afs/fs_probe.c

257

old = rcu_dereference_protected(server->endpoint_state,

fs/afs/fs_probe.c

258

lockdep_is_held(&server->fs_lock));

fs/afs/fs_probe.c

266

afs_set_peer_appdata(server, old_alist, new_alist);

fs/afs/fs_probe.c

270

estate->probe_seq = ++server->probe_counter;

fs/afs/fs_probe.c

274

server->addr_version = new_alist->version;

fs/afs/fs_probe.c

275

rcu_assign_pointer(server->endpoint_state, estate);

fs/afs/fs_probe.c

276

write_unlock(&server->fs_lock);

fs/afs/fs_probe.c

285

server->probed_at = jiffies;

fs/afs/fs_probe.c

300

trace_afs_fs_probe(server, true, estate, index, 0, 0, 0);

fs/afs/fs_probe.c

301

if (!afs_fs_get_capabilities(net, server, estate, index, key))

fs/afs/fs_probe.c

302

afs_fs_probe_not_done(net, server, estate, index);

fs/afs/fs_probe.c

336

add_wait_queue(&slist->servers[i].server->probe_wq, &states[i].probe_waiter);

fs/afs/fs_probe.c

365

remove_wait_queue(&slist->servers[i].server->probe_wq, &states[i].probe_waiter);

fs/afs/fs_probe.c

387

static void afs_dispatch_fs_probe(struct afs_net *net, struct afs_server *server)

fs/afs/fs_probe.c

395

list_del_init(&server->probe_link);

fs/afs/fs_probe.c

397

afs_get_server(server, afs_server_trace_get_probe);

fs/afs/fs_probe.c

400

afs_fs_probe_fileserver(net, server, NULL, key);

fs/afs/fs_probe.c

401

afs_put_server(net, server, afs_server_trace_put_probe);

fs/afs/fs_probe.c

408

void afs_probe_fileserver(struct afs_net *net, struct afs_server *server)

fs/afs/fs_probe.c

411

if (!list_empty(&server->probe_link))

fs/afs/fs_probe.c

412

return afs_dispatch_fs_probe(net, server);

fs/afs/fs_probe.c

422

struct afs_server *fast, *slow, *server;

fs/afs/fs_probe.c

442

fast = slow = server = NULL;

fs/afs/fs_probe.c

467

server = fast ?: slow;

fs/afs/fs_probe.c

468

if (server)

fs/afs/fs_probe.c

469

_debug("probe %pU", &server->uuid);

fs/afs/fs_probe.c

471

if (server && (first_pass || !need_resched())) {

fs/afs/fs_probe.c

472

afs_dispatch_fs_probe(net, server);

fs/afs/fs_probe.c

479

if (server) {

fs/afs/fs_probe.c

496

int afs_wait_for_one_fs_probe(struct afs_server *server, struct afs_endpoint_state *estate,

fs/afs/fs_probe.c

507

prepare_to_wait_event(&server->probe_wq, &wait,

fs/afs/fs_probe.c

518

finish_wait(&server->probe_wq, &wait);

fs/afs/fs_probe.c

59

struct afs_server *server, bool fast)

fs/afs/fs_probe.c

66

atj = server->probed_at;

fs/afs/fs_probe.c

77

static void afs_finished_fs_probe(struct afs_net *net, struct afs_server *server,

fs/afs/fs_probe.c

84

list_add_tail(&server->probe_link, &net->fs_probe_slow);

fs/afs/fs_probe.c

86

server->rtt = UINT_MAX;

fs/afs/fs_probe.c

87

clear_bit(AFS_SERVER_FL_RESPONDING, &server->flags);

fs/afs/fs_probe.c

88

list_add_tail(&server->probe_link, &net->fs_probe_fast);

fs/afs/fs_probe.c

93

afs_schedule_fs_probe(net, server, !responded);

fs/afs/fs_probe.c

99

static void afs_done_one_fs_probe(struct afs_net *net, struct afs_server *server,

fs/afs/fsclient.c

1133

if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))

fs/afs/fsclient.c

1249

if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))

fs/afs/fsclient.c

1635

int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,

fs/afs/fsclient.c

1650

call->service_id = server->service_id;

fs/afs/fsclient.c

1656

call->server = afs_use_server(server, false, afs_server_trace_use_give_up_cb);

fs/afs/fsclient.c

1661

set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);

fs/afs/fsclient.c

1749

bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,

fs/afs/fsclient.c

1763

call->server = afs_use_server(server, false, afs_server_trace_use_get_caps);

fs/afs/fsclient.c

1767

call->service_id = server->service_id;

fs/afs/fsclient.c

1921

set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);

fs/afs/fsclient.c

1949

if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) {

fs/afs/fsclient.c

471

if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))

fs/afs/inode.c

239

vnode->cb_server = op->server;

fs/afs/inode.c

370

vnode->cb_server = op->server;

fs/afs/internal.h

1015

void afs_set_peer_appdata(struct afs_server *server,

fs/afs/internal.h

1191

int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,

fs/afs/internal.h

1193

bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,

fs/afs/internal.h

1236

int afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server,

fs/afs/internal.h

1241

int afs_wait_for_one_fs_probe(struct afs_server *server, struct afs_endpoint_state *estate,

fs/afs/internal.h

139

struct afs_server *server; /* The fileserver record if fs op (pins ref) */

fs/afs/internal.h

1428

call->service_id = op->server->service_id;

fs/afs/internal.h

1541

struct afs_server *afs_use_server(struct afs_server *server, bool activate,

fs/afs/internal.h

1543

void afs_unuse_server(struct afs_net *net, struct afs_server *server,

fs/afs/internal.h

1545

void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,

fs/afs/internal.h

1551

bool afs_check_server_record(struct afs_operation *op, struct afs_server *server, struct key *key);

fs/afs/internal.h

1553

static inline void afs_see_server(struct afs_server *server, enum afs_server_trace trace)

fs/afs/internal.h

1555

int r = refcount_read(&server->ref);

fs/afs/internal.h

1556

int a = atomic_read(&server->active);

fs/afs/internal.h

1558

trace_afs_server(server->debug_id, r, a, trace);

fs/afs/internal.h

1573

static inline bool afs_is_probing_server(struct afs_server *server)

fs/afs/internal.h

1575

return list_empty(&server->probe_link);

fs/afs/internal.h

1620

struct afs_vlserver *server,

fs/afs/internal.h

464

struct afs_vlserver *server;

fs/afs/internal.h

597

struct afs_server *server;

fs/afs/internal.h

796

struct afs_vlserver *server; /* Server on which this resides */

fs/afs/internal.h

928

struct afs_server *server; /* Server we're using (ref pinned by server_list) */

fs/afs/proc.c

357

vlserver = entry->server;

fs/afs/proc.c

438

struct afs_server *server;

fs/afs/proc.c

447

server = list_entry(v, struct afs_server, proc_link);

fs/afs/proc.c

449

&server->uuid,

fs/afs/proc.c

450

refcount_read(&server->ref),

fs/afs/proc.c

451

atomic_read(&server->active),

fs/afs/proc.c

452

server->cell->name);

fs/afs/proc.c

454

server->flags, server->rtt);

fs/afs/proc.c

456

(int)(jiffies - server->probed_at) / HZ);

fs/afs/proc.c

458

estate = rcu_dereference(server->endpoint_state);

fs/afs/rotate.c

126

op->volume->vid, op->volume->name, &op->server->uuid, m);

fs/afs/rotate.c

155

struct afs_server *server;

fs/afs/rotate.c

37

struct afs_server *server;

fs/afs/rotate.c

484

op->server = NULL;

fs/afs/rotate.c

533

if (op->server) {

fs/afs/rotate.c

537

op->server = NULL;

fs/afs/rotate.c

548

struct afs_server *s = se->server;

fs/afs/rotate.c

584

server = op->server_list->servers[op->server_index].server;

fs/afs/rotate.c

586

if (!afs_check_server_record(op, server, op->key))

fs/afs/rotate.c

589

_debug("USING SERVER: %pU", &server->uuid);

fs/afs/rotate.c

592

op->server = server;

fs/afs/rotate.c

593

if (vnode->cb_server != server) {

fs/afs/rotate.c

594

vnode->cb_server = server;

fs/afs/rotate.c

62

server = op->server_list->servers[i].server;

fs/afs/rotate.c

63

estate = rcu_dereference(server->endpoint_state);

fs/afs/rotate.c

644

error = afs_wait_for_one_fs_probe(op->server, op->estate, op->addr_tried,

fs/afs/rotate.c

655

afs_probe_fileserver(op->net, op->server);

fs/afs/rotate.c

657

error = afs_wait_for_one_fs_probe(op->server, op->estate, op->addr_tried,

fs/afs/rotate.c

741

const struct afs_server *s = sl->servers[i].server;

fs/afs/rotate.c

81

server = op->server_list->servers[i].server;

fs/afs/rotate.c

82

if (server == cb_server) {

fs/afs/rxrpc.c

201

afs_unuse_server_notime(call->net, call->server, afs_server_trace_unuse_call);

fs/afs/rxrpc.c

561

&call->op->server->flags);

fs/afs/rxrpc.c

791

call->server = afs_find_server(call->peer);

fs/afs/rxrpc.c

792

if (!call->server)

fs/afs/server.c

100

hlist_add_head_rcu(&server->proc_link, &net->fs_proc);

fs/afs/server.c

106

afs_use_server(server, true, afs_server_trace_use_install);

fs/afs/server.c

107

return server;

fs/afs/server.c

115

struct afs_server *server;

fs/afs/server.c

120

server = kzalloc_obj(struct afs_server);

fs/afs/server.c

121

if (!server)

fs/afs/server.c

124

refcount_set(&server->ref, 1);

fs/afs/server.c

125

atomic_set(&server->active, 0);

fs/afs/server.c

126

__set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);

fs/afs/server.c

127

server->debug_id = atomic_inc_return(&afs_server_debug_id);

fs/afs/server.c

128

server->uuid = *uuid;

fs/afs/server.c

129

rwlock_init(&server->fs_lock);

fs/afs/server.c

130

INIT_WORK(&server->destroyer, &afs_server_destroyer);

fs/afs/server.c

131

timer_setup(&server->timer, afs_server_timer, 0);

fs/afs/server.c

132

INIT_LIST_HEAD(&server->volumes);

fs/afs/server.c

133

init_waitqueue_head(&server->probe_wq);

fs/afs/server.c

134

mutex_init(&server->cm_token_lock);

fs/afs/server.c

135

INIT_LIST_HEAD(&server->probe_link);

fs/afs/server.c

136

INIT_HLIST_NODE(&server->proc_link);

fs/afs/server.c

137

spin_lock_init(&server->probe_lock);

fs/afs/server.c

138

server->cell = cell;

fs/afs/server.c

139

server->rtt = UINT_MAX;

fs/afs/server.c

140

server->service_id = FS_SERVICE;

fs/afs/server.c

141

server->probe_counter = 1;

fs/afs/server.c

142

server->probed_at = jiffies - LONG_MAX / 2;

fs/afs/server.c

145

_leave(" = %p", server);

fs/afs/server.c

146

return server;

fs/afs/server.c

152

static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_server *server,

fs/afs/server.c

160

if (afs_begin_vlserver_operation(&vc, server->cell, key)) {

fs/afs/server.c

162

if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))

fs/afs/server.c

163

alist = afs_yfsvl_get_endpoints(&vc, &server->uuid);

fs/afs/server.c

165

alist = afs_vl_get_addrs_u(&vc, &server->uuid);

fs/afs/server.c

182

struct afs_server *server, *candidate = NULL;

fs/afs/server.c

189

server = afs_find_server_by_uuid(cell, uuid);

fs/afs/server.c

193

if (server) {

fs/afs/server.c

194

timer_delete_sync(&server->timer);

fs/afs/server.c

195

if (test_bit(AFS_SERVER_FL_CREATING, &server->flags))

fs/afs/server.c

197

if (server->addr_version != addr_version)

fs/afs/server.c

198

set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);

fs/afs/server.c

199

return server;

fs/afs/server.c

209

server = afs_install_server(cell, &candidate);

fs/afs/server.c

210

if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) {

fs/afs/server.c

215

if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {

fs/afs/server.c

216

set_bit(AFS_SERVER_FL_CREATING, &server->flags);

fs/afs/server.c

217

clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags);

fs/afs/server.c

221

timer_delete_sync(&server->timer);

fs/afs/server.c

229

alist = afs_vl_lookup_addrs(server, key);

fs/afs/server.c

235

ret = afs_fs_probe_fileserver(cell->net, server, alist, key);

fs/afs/server.c

239

clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags);

fs/afs/server.c

245

kfree(rcu_access_pointer(server->endpoint_state));

fs/afs/server.c

249

return server ?: ERR_PTR(ret);

fs/afs/server.c

252

afs_see_server(server, afs_server_trace_wait_create);

fs/afs/server.c

253

wait_on_bit(&server->flags, AFS_SERVER_FL_CREATING, TASK_UNINTERRUPTIBLE);

fs/afs/server.c

254

if (test_bit_acquire(AFS_SERVER_FL_UNCREATED, &server->flags)) {

fs/afs/server.c

256

ret = READ_ONCE(server->create_error);

fs/afs/server.c

257

afs_put_server(cell->net, server, afs_server_trace_unuse_create_fail);

fs/afs/server.c

258

server = NULL;

fs/afs/server.c

26

struct afs_server *server = (struct afs_server *)rxrpc_kernel_get_peer_data(peer);

fs/afs/server.c

268

WRITE_ONCE(server->create_error, ret);

fs/afs/server.c

270

set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);

fs/afs/server.c

272

clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags);

fs/afs/server.c

274

if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {

fs/afs/server.c

275

clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags);

fs/afs/server.c

278

afs_unuse_server(cell->net, server, afs_server_trace_unuse_create_fail);

fs/afs/server.c

279

server = NULL;

fs/afs/server.c

28

if (!server)

fs/afs/server.c

288

static void afs_set_server_timer(struct afs_server *server, unsigned int delay_secs)

fs/afs/server.c

290

mod_timer(&server->timer, jiffies + delay_secs * HZ);

fs/afs/server.c

296

struct afs_server *afs_get_server(struct afs_server *server,

fs/afs/server.c

30

return afs_use_server(server, false, afs_server_trace_use_cm_call);

fs/afs/server.c

302

__refcount_inc(&server->ref, &r);

fs/afs/server.c

303

a = atomic_read(&server->active);

fs/afs/server.c

304

trace_afs_server(server->debug_id, r + 1, a, reason);

fs/afs/server.c

305

return server;

fs/afs/server.c

312

struct afs_server *afs_use_server(struct afs_server *server, bool activate,

fs/afs/server.c

318

__refcount_inc(&server->ref, &r);

fs/afs/server.c

319

a = atomic_inc_return(&server->active);

fs/afs/server.c

321

!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))

fs/afs/server.c

322

timer_delete(&server->timer);

fs/afs/server.c

324

trace_afs_server(server->debug_id, r + 1, a, reason);

fs/afs/server.c

325

return server;

fs/afs/server.c

331

void afs_put_server(struct afs_net *net, struct afs_server *server,

fs/afs/server.c

338

if (!server)

fs/afs/server.c

341

debug_id = server->debug_id;

fs/afs/server.c

342

a = atomic_read(&server->active);

fs/afs/server.c

343

zero = __refcount_dec_and_test(&server->ref, &r);

fs/afs/server.c

346

__afs_put_server(net, server);

fs/afs/server.c

353

void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,

fs/afs/server.c

356

if (!server)

fs/afs/server.c

359

if (atomic_dec_and_test(&server->active)) {

fs/afs/server.c

360

if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) ||

fs/afs/server.c

361

READ_ONCE(server->cell->state) >= AFS_CELL_REMOVING)

fs/afs/server.c

362

schedule_work(&server->destroyer);

fs/afs/server.c

365

afs_put_server(net, server, reason);

fs/afs/server.c

371

void afs_unuse_server(struct afs_net *net, struct afs_server *server,

fs/afs/server.c

374

if (!server)

fs/afs/server.c

377

if (atomic_dec_and_test(&server->active)) {

fs/afs/server.c

378

if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) &&

fs/afs/server.c

379

READ_ONCE(server->cell->state) < AFS_CELL_REMOVING) {

fs/afs/server.c

382

server->unuse_time = unuse_time;

fs/afs/server.c

383

afs_set_server_timer(server, afs_server_gc_delay);

fs/afs/server.c

385

schedule_work(&server->destroyer);

fs/afs/server.c

389

afs_put_server(net, server, reason);

fs/afs/server.c

39

struct afs_server *server;

fs/afs/server.c

394

struct afs_server *server = container_of(rcu, struct afs_server, rcu);

fs/afs/server.c

396

trace_afs_server(server->debug_id, refcount_read(&server->ref),

fs/afs/server.c

397

atomic_read(&server->active), afs_server_trace_free);

fs/afs/server.c

398

afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state),

fs/afs/server.c

400

afs_put_cell(server->cell, afs_cell_trace_put_server);

fs/afs/server.c

401

kfree(server->cm_rxgk_appdata.data);

fs/afs/server.c

402

kfree(server);

fs/afs/server.c

405

static void __afs_put_server(struct afs_net *net, struct afs_server *server)

fs/afs/server.c

407

call_rcu(&server->rcu, afs_server_rcu);

fs/afs/server.c

411

static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)

fs/afs/server.c

413

struct afs_endpoint_state *estate = rcu_access_pointer(server->endpoint_state);

fs/afs/server.c

416

afs_fs_give_up_all_callbacks(net, server, &alist->addrs[alist->preferred], NULL);

fs/afs/server.c

422

static bool afs_has_server_expired(const struct afs_server *server)

fs/afs/server.c

426

if (atomic_read(&server->active))

fs/afs/server.c

429

if (server->cell->net->live ||

fs/afs/server.c

430

server->cell->state >= AFS_CELL_REMOVING) {

fs/afs/server.c

431

trace_afs_server(server->debug_id, refcount_read(&server->ref),

fs/afs/server.c

436

expires_at = server->unuse_time;

fs/afs/server.c

437

if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&

fs/afs/server.c

438

!test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))

fs/afs/server.c

447

static bool afs_remove_server_from_cell(struct afs_server *server)

fs/afs/server.c

449

struct afs_cell *cell = server->cell;

fs/afs/server.c

453

if (!afs_has_server_expired(server)) {

fs/afs/server.c

458

set_bit(AFS_SERVER_FL_EXPIRED, &server->flags);

fs/afs/server.c

459

_debug("expire %pU %u", &server->uuid, atomic_read(&server->active));

fs/afs/server.c

460

afs_see_server(server, afs_server_trace_see_expired);

fs/afs/server.c

461

rb_erase(&server->uuid_rb, &cell->fs_servers);

fs/afs/server.c

469

struct afs_server *server = container_of(work, struct afs_server, destroyer);

fs/afs/server.c

47

server = rb_entry(p, struct afs_server, uuid_rb);

fs/afs/server.c

470

struct afs_net *net = server->cell->net;

fs/afs/server.c

472

afs_see_server(server, afs_server_trace_see_destroyer);

fs/afs/server.c

474

if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))

fs/afs/server.c

477

if (!afs_remove_server_from_cell(server))

fs/afs/server.c

480

timer_shutdown_sync(&server->timer);

fs/afs/server.c

481

cancel_work(&server->destroyer);

fs/afs/server.c

483

if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))

fs/afs/server.c

484

afs_give_up_callbacks(net, server);

fs/afs/server.c

487

estate = rcu_access_pointer(server->endpoint_state);

fs/afs/server.c

489

afs_set_peer_appdata(server, estate->addresses, NULL);

fs/afs/server.c

49

diff = memcmp(uuid, &server->uuid, sizeof(*uuid));

fs/afs/server.c

492

list_del_init(&server->probe_link);

fs/afs/server.c

493

if (!hlist_unhashed(&server->proc_link))

fs/afs/server.c

494

hlist_del_rcu(&server->proc_link);

fs/afs/server.c

497

afs_put_server(net, server, afs_server_trace_destroy);

fs/afs/server.c

502

struct afs_server *server = container_of(timer, struct afs_server, timer);

fs/afs/server.c

504

afs_see_server(server, afs_server_trace_see_timer);

fs/afs/server.c

505

if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))

fs/afs/server.c

506

schedule_work(&server->destroyer);

fs/afs/server.c

514

struct afs_server *server;

fs/afs/server.c

519

server = rb_entry(rb, struct afs_server, uuid_rb);

fs/afs/server.c

520

afs_see_server(server, afs_server_trace_see_purge);

fs/afs/server.c

521

schedule_work(&server->destroyer);

fs/afs/server.c

543

struct afs_server *server,

fs/afs/server.c

55

if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags))

fs/afs/server.c

552

trace_afs_server(server->debug_id, refcount_read(&server->ref),

fs/afs/server.c

553

atomic_read(&server->active),

fs/afs/server.c

556

alist = afs_vl_lookup_addrs(server, op->key);

fs/afs/server.c

559

estate = rcu_dereference(server->endpoint_state);

fs/afs/server.c

57

afs_use_server(server, true, afs_server_trace_use_by_uuid);

fs/afs/server.c

575

if (server->addr_version != alist->version)

fs/afs/server.c

576

afs_fs_probe_fileserver(op->net, server, alist, key);

fs/afs/server.c

58

return server;

fs/afs/server.c

586

bool afs_check_server_record(struct afs_operation *op, struct afs_server *server,

fs/afs/server.c

594

ASSERT(server);

fs/afs/server.c

597

if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags))

fs/afs/server.c

599

if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags))

fs/afs/server.c

605

if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {

fs/afs/server.c

606

clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);

fs/afs/server.c

607

success = afs_update_server_record(op, server, key);

fs/afs/server.c

608

clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);

fs/afs/server.c

609

wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);

fs/afs/server.c

615

ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,

fs/afs/server.c

72

struct afs_server *server;

fs/afs/server.c

85

server = rb_entry(p, struct afs_server, uuid_rb);

fs/afs/server.c

86

diff = memcmp(&(*candidate)->uuid, &server->uuid, sizeof(uuid_t));

fs/afs/server.c

95

server = *candidate;

fs/afs/server.c

97

rb_link_node(&server->uuid_rb, p, pp);

fs/afs/server.c

98

rb_insert_color(&server->uuid_rb, &cell->fs_servers);

fs/afs/server_list.c

100

afs_unuse_server_notime(volume->cell->net, server,

fs/afs/server_list.c

110

slist->servers[j].server = server;

fs/afs/server_list.c

144

if (old->servers[i].server != new->servers[i].server)

fs/afs/server_list.c

160

struct afs_server *server;

fs/afs/server_list.c

168

server = se->server;

fs/afs/server_list.c

170

list_for_each(p, &server->volumes) {

fs/afs/server_list.c

18

afs_unuse_server(net, slist->servers[i].server,

fs/afs/server_list.c

201

if (pn && po && pn->server == po->server) {

fs/afs/server_list.c

210

diff = memcmp(&pn->server->uuid, &po->server->uuid,

fs/afs/server_list.c

211

sizeof(pn->server->uuid));

fs/afs/server_list.c

216

list_for_each(p, &pn->server->volumes) {

fs/afs/server_list.c

32

struct afs_server *server;

fs/afs/server_list.c

82

server = afs_lookup_server(volume->cell, key, &vldb->fs_server[i],

fs/afs/server_list.c

84

if (IS_ERR(server)) {

fs/afs/server_list.c

85

ret = PTR_ERR(server);

fs/afs/server_list.c

94

if (memcmp(&slist->servers[j].server->uuid,

fs/afs/server_list.c

95

&server->uuid,

fs/afs/server_list.c

96

sizeof(server->uuid)) >= 0)

fs/afs/server_list.c

99

if (slist->servers[j].server == server) {

fs/afs/validation.c

165

if (op->server == se->server) {

fs/afs/vl_alias.c

238

if (!test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) {

fs/afs/vl_alias.c

84

const struct afs_server *server_a = la->servers[a].server;

fs/afs/vl_alias.c

85

const struct afs_server *server_b = lb->servers[b].server;

fs/afs/vl_list.c

166

struct afs_vlserver *server;

fs/afs/vl_list.c

234

server = NULL;

fs/afs/vl_list.c

236

struct afs_vlserver *p = previous->servers[i].server;

fs/afs/vl_list.c

241

server = afs_get_vlserver(p);

fs/afs/vl_list.c

246

if (!server) {

fs/afs/vl_list.c

248

server = afs_alloc_vlserver(b, bs.name_len, bs.port);

fs/afs/vl_list.c

249

if (!server)

fs/afs/vl_list.c

267

afs_put_vlserver(cell->net, server);

fs/afs/vl_list.c

276

if (!rcu_access_pointer(server->addresses)) {

fs/afs/vl_list.c

277

afs_put_vlserver(cell->net, server);

fs/afs/vl_list.c

283

write_lock(&server->lock);

fs/afs/vl_list.c

284

old = rcu_replace_pointer(server->addresses, old,

fs/afs/vl_list.c

285

lockdep_is_held(&server->lock));

fs/afs/vl_list.c

286

write_unlock(&server->lock);

fs/afs/vl_list.c

308

clear_bit(AFS_VLSERVER_FL_PROBED, &server->flags);

fs/afs/vl_list.c

312

vllist->servers[j].server = server;

fs/afs/vl_list.c

326

afs_put_vlserver(cell->net, server);

fs/afs/vl_list.c

70

afs_put_vlserver(net, vllist->servers[i].server);

fs/afs/vl_probe.c

108

server->probe.flags |= AFS_VLSERVER_PROBE_IS_YFS;

fs/afs/vl_probe.c

109

set_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);

fs/afs/vl_probe.c

110

server->service_id = call->service_id;

fs/afs/vl_probe.c

112

server->probe.flags |= AFS_VLSERVER_PROBE_NOT_YFS;

fs/afs/vl_probe.c

113

if (!(server->probe.flags & AFS_VLSERVER_PROBE_IS_YFS)) {

fs/afs/vl_probe.c

114

clear_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);

fs/afs/vl_probe.c

115

server->service_id = call->service_id;

fs/afs/vl_probe.c

120

if (rtt_us < server->probe.rtt) {

fs/afs/vl_probe.c

121

server->probe.rtt = rtt_us;

fs/afs/vl_probe.c

122

server->rtt = rtt_us;

fs/afs/vl_probe.c

127

server->probe.flags |= AFS_VLSERVER_PROBE_RESPONDED;

fs/afs/vl_probe.c

128

set_bit(AFS_VLSERVER_FL_PROBED, &server->flags);

fs/afs/vl_probe.c

129

set_bit(AFS_VLSERVER_FL_RESPONDING, &server->flags);

fs/afs/vl_probe.c

132

spin_unlock(&server->probe_lock);

fs/afs/vl_probe.c

134

trace_afs_vl_probe(server, false, alist, index, call->error, call->abort_code, rtt_us);

fs/afs/vl_probe.c

139

afs_done_one_vl_probe(server, have_result);

fs/afs/vl_probe.c

147

struct afs_vlserver *server,

fs/afs/vl_probe.c

159

_enter("%s", server->name);

fs/afs/vl_probe.c

161

read_lock(&server->lock);

fs/afs/vl_probe.c

162

alist = rcu_dereference_protected(server->addresses,

fs/afs/vl_probe.c

163

lockdep_is_held(&server->lock));

fs/afs/vl_probe.c

165

read_unlock(&server->lock);

fs/afs/vl_probe.c

167

atomic_set(&server->probe_outstanding, alist->nr_addrs);

fs/afs/vl_probe.c

168

memset(&server->probe, 0, sizeof(server->probe));

fs/afs/vl_probe.c

169

server->probe.rtt = UINT_MAX;

fs/afs/vl_probe.c

18

static void afs_finished_vl_probe(struct afs_vlserver *server)

fs/afs/vl_probe.c

184

trace_afs_vl_probe(server, true, alist, index, 0, 0, 0);

fs/afs/vl_probe.c

185

call = afs_vl_get_capabilities(net, alist, index, key, server,

fs/afs/vl_probe.c

193

afs_done_one_vl_probe(server, false);

fs/afs/vl_probe.c

20

if (!(server->probe.flags & AFS_VLSERVER_PROBE_RESPONDED)) {

fs/afs/vl_probe.c

207

struct afs_vlserver *server;

fs/afs/vl_probe.c

21

server->rtt = UINT_MAX;

fs/afs/vl_probe.c

213

server = vllist->servers[i].server;

fs/afs/vl_probe.c

214

if (test_bit(AFS_VLSERVER_FL_PROBED, &server->flags))

fs/afs/vl_probe.c

217

if (!test_and_set_bit_lock(AFS_VLSERVER_FL_PROBING, &server->flags) &&

fs/afs/vl_probe.c

218

afs_do_probe_vlserver(net, server, key, i, &e))

fs/afs/vl_probe.c

22

clear_bit(AFS_VLSERVER_FL_RESPONDING, &server->flags);

fs/afs/vl_probe.c

232

struct afs_vlserver *server;

fs/afs/vl_probe.c

242

server = vllist->servers[i].server;

fs/afs/vl_probe.c

243

if (!test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))

fs/afs/vl_probe.c

245

if (server->probe.flags & AFS_VLSERVER_PROBE_RESPONDED)

fs/afs/vl_probe.c

25

clear_bit_unlock(AFS_VLSERVER_FL_PROBING, &server->flags);

fs/afs/vl_probe.c

258

server = vllist->servers[i].server;

fs/afs/vl_probe.c

26

wake_up_bit(&server->flags, AFS_VLSERVER_FL_PROBING);

fs/afs/vl_probe.c

260

add_wait_queue(&server->probe_wq, &waits[i]);

fs/afs/vl_probe.c

270

server = vllist->servers[i].server;

fs/afs/vl_probe.c

271

if (server->probe.flags & AFS_VLSERVER_PROBE_RESPONDED)

fs/afs/vl_probe.c

273

if (test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))

fs/afs/vl_probe.c

288

server = vllist->servers[i].server;

fs/afs/vl_probe.c

289

rtt_s = READ_ONCE(server->rtt);

fs/afs/vl_probe.c

290

if (test_bit(AFS_VLSERVER_FL_RESPONDING, &server->flags) &&

fs/afs/vl_probe.c

296

remove_wait_queue(&server->probe_wq, &waits[i]);

fs/afs/vl_probe.c

32

static void afs_done_one_vl_probe(struct afs_vlserver *server, bool wake_up)

fs/afs/vl_probe.c

34

if (atomic_dec_and_test(&server->probe_outstanding)) {

fs/afs/vl_probe.c

35

afs_finished_vl_probe(server);

fs/afs/vl_probe.c

40

wake_up_all(&server->probe_wq);

fs/afs/vl_probe.c

50

struct afs_vlserver *server = call->vlserver;

fs/afs/vl_probe.c

58

_enter("%s,%u,%u,%d,%d", server->name, server_index, index, ret, call->abort_code);

fs/afs/vl_probe.c

60

spin_lock(&server->probe_lock);

fs/afs/vl_probe.c

64

server->probe.error = 0;

fs/afs/vl_probe.c

67

if (!(server->probe.flags & AFS_VLSERVER_PROBE_RESPONDED)) {

fs/afs/vl_probe.c

68

server->probe.abort_code = call->abort_code;

fs/afs/vl_probe.c

69

server->probe.error = ret;

fs/afs/vl_probe.c

77

server->probe.flags |= AFS_VLSERVER_PROBE_LOCAL_FAILURE;

fs/afs/vl_probe.c

78

if (server->probe.error == 0)

fs/afs/vl_probe.c

79

server->probe.error = ret;

fs/afs/vl_probe.c

94

if (!(server->probe.flags & AFS_VLSERVER_PROBE_RESPONDED) &&

fs/afs/vl_probe.c

95

(server->probe.error == 0 ||

fs/afs/vl_probe.c

96

server->probe.error == -ETIMEDOUT ||

fs/afs/vl_probe.c

97

server->probe.error == -ETIME))

fs/afs/vl_probe.c

98

server->probe.error = ret;

fs/afs/vl_rotate.c

217

struct afs_vlserver *s = vc->server_list->servers[i].server;

fs/afs/vl_rotate.c

239

vlserver = vc->server_list->servers[vc->server_index].server;

fs/afs/vl_rotate.c

240

vc->server = vlserver;

fs/afs/vl_rotate.c

299

struct afs_vlserver *s = vc->server_list->servers[i].server;

fs/afs/vl_rotate.c

350

const struct afs_vlserver *s = sl->servers[i].server;

fs/afs/vlclient.c

140

call->service_id = vc->server->service_id;

fs/afs/vlclient.c

281

call->service_id = vc->server->service_id;

fs/afs/vlclient.c

389

struct afs_vlserver *server,

fs/afs/vlclient.c

402

call->vlserver = afs_get_vlserver(server);

fs/afs/vlclient.c

407

call->service_id = server->service_id;

fs/afs/vlclient.c

654

call->service_id = vc->server->service_id;

fs/afs/vlclient.c

773

call->service_id = vc->server->service_id;

fs/afs/yfsclient.c

1045

if (!test_bit(AFS_SERVER_FL_NO_RENAME2, &op->server->flags))

fs/afs/yfsclient.c

1149

set_bit(AFS_SERVER_FL_NO_RENAME2, &call->op->server->flags);

fs/afs/yfsclient.c

672

set_bit(AFS_SERVER_FL_NO_RM2, &call->op->server->flags);

fs/afs/yfsclient.c

769

if (!test_bit(AFS_SERVER_FL_NO_RM2, &op->server->flags))

fs/lockd/host.c

146

host->h_server = ni->server;

fs/lockd/host.c

225

.server = 0,

fs/lockd/host.c

338

.server = 1,

fs/lockd/host.c

54

const int server; /* search for server|client */

fs/nfs/blocklayout/blocklayout.c

562

bl_find_get_deviceid(struct nfs_server *server,

fs/nfs/blocklayout/blocklayout.c

570

node = nfs4_find_get_deviceid(server, id, cred, gfp_mask);

fs/nfs/blocklayout/blocklayout.c

804

bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)

fs/nfs/blocklayout/blocklayout.c

808

if (server->pnfs_blksize == 0) {

fs/nfs/blocklayout/blocklayout.c

812

if (server->pnfs_blksize > PAGE_SIZE) {

fs/nfs/blocklayout/blocklayout.c

814

__func__, server->pnfs_blksize);

fs/nfs/blocklayout/blocklayout.h

182

struct nfs4_deviceid_node *bl_alloc_deviceid_node(struct nfs_server *server,

fs/nfs/blocklayout/blocklayout.h

199

dev_t bl_resolve_deviceid(struct nfs_server *server,

fs/nfs/blocklayout/dev.c

289

bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

294

bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

301

dev = bl_resolve_deviceid(server, v, gfp_mask);

fs/nfs/blocklayout/dev.c

385

bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

441

bl_parse_slice(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

447

ret = bl_parse_deviceid(server, d, volumes, v->slice.volume, gfp_mask);

fs/nfs/blocklayout/dev.c

457

bl_parse_concat(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

470

ret = bl_parse_deviceid(server, &d->children[i],

fs/nfs/blocklayout/dev.c

486

bl_parse_stripe(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

499

ret = bl_parse_deviceid(server, &d->children[i],

fs/nfs/blocklayout/dev.c

515

bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,

fs/nfs/blocklayout/dev.c

522

return bl_parse_simple(server, d, volumes, idx, gfp_mask);

fs/nfs/blocklayout/dev.c

524

return bl_parse_slice(server, d, volumes, idx, gfp_mask);

fs/nfs/blocklayout/dev.c

526

return bl_parse_concat(server, d, volumes, idx, gfp_mask);

fs/nfs/blocklayout/dev.c

528

return bl_parse_stripe(server, d, volumes, idx, gfp_mask);

fs/nfs/blocklayout/dev.c

530

return bl_parse_scsi(server, d, volumes, idx, gfp_mask);

fs/nfs/blocklayout/dev.c

538

bl_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,

fs/nfs/blocklayout/dev.c

576

ret = bl_parse_deviceid(server, top, volumes, nr_volumes - 1, gfp_mask);

fs/nfs/blocklayout/dev.c

579

nfs4_init_deviceid_node(node, server, &pdev->dev_id);

fs/nfs/blocklayout/rpc_pipefs.c

52

bl_resolve_deviceid(struct nfs_server *server, struct pnfs_block_volume *b,

fs/nfs/blocklayout/rpc_pipefs.c

55

struct net *net = server->nfs_client->cl_net;

fs/nfs/callback_proc.c

138

struct nfs_server *server;

fs/nfs/callback_proc.c

143

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/callback_proc.c

144

list_for_each_entry_rcu(lo, &server->layouts, plh_layouts) {

fs/nfs/callback_proc.c

149

if (nfs_sb_active(server->super))

fs/nfs/callback_proc.c

156

nfs_sb_deactive(server->super);

fs/nfs/callback_proc.c

173

struct nfs_server *server;

fs/nfs/callback_proc.c

179

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/callback_proc.c

180

list_for_each_entry_rcu(lo, &server->layouts, plh_layouts) {

fs/nfs/callback_proc.c

186

if (nfs_sb_active(server->super))

fs/nfs/callback_proc.c

193

nfs_sb_deactive(server->super);

fs/nfs/callback_proc.c

717

struct nfs_server *server;

fs/nfs/callback_proc.c

727

list_for_each_entry_rcu(server, &cps->clp->cl_superblocks,

fs/nfs/callback_proc.c

729

list_for_each_entry(tmp_copy, &server->ss_copies, copies) {

fs/nfs/client.c

1005

void nfs_server_insert_lists(struct nfs_server *server)

fs/nfs/client.c

1007

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

1011

list_add_tail_rcu(&server->client_link, &clp->cl_superblocks);

fs/nfs/client.c

1012

list_add_tail(&server->master_link, &nn->nfs_volume_list);

fs/nfs/client.c

1019

void nfs_server_remove_lists(struct nfs_server *server)

fs/nfs/client.c

1021

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

1028

list_del_rcu(&server->client_link);

fs/nfs/client.c

1031

list_del(&server->master_link);

fs/nfs/client.c

1045

struct nfs_server *server;

fs/nfs/client.c

1047

server = kzalloc_obj(struct nfs_server);

fs/nfs/client.c

1048

if (!server)

fs/nfs/client.c

1051

server->s_sysfs_id = ida_alloc(&s_sysfs_ids, GFP_KERNEL);

fs/nfs/client.c

1052

if (server->s_sysfs_id < 0) {

fs/nfs/client.c

1053

kfree(server);

fs/nfs/client.c

1057

server->client = server->client_acl = ERR_PTR(-EINVAL);

fs/nfs/client.c

1060

INIT_LIST_HEAD(&server->client_link);

fs/nfs/client.c

1061

INIT_LIST_HEAD(&server->master_link);

fs/nfs/client.c

1062

INIT_LIST_HEAD(&server->delegations);

fs/nfs/client.c

1063

spin_lock_init(&server->delegations_lock);

fs/nfs/client.c

1064

INIT_LIST_HEAD(&server->delegations_return);

fs/nfs/client.c

1065

INIT_LIST_HEAD(&server->delegations_lru);

fs/nfs/client.c

1066

INIT_LIST_HEAD(&server->delegations_delayed);

fs/nfs/client.c

1067

INIT_LIST_HEAD(&server->layouts);

fs/nfs/client.c

1068

INIT_LIST_HEAD(&server->state_owners_lru);

fs/nfs/client.c

1069

INIT_LIST_HEAD(&server->ss_copies);

fs/nfs/client.c

1070

INIT_LIST_HEAD(&server->ss_src_copies);

fs/nfs/client.c

1072

atomic_set(&server->active, 0);

fs/nfs/client.c

1073

atomic_long_set(&server->nr_active_delegations, 0);

fs/nfs/client.c

1075

server->io_stats = nfs_alloc_iostats();

fs/nfs/client.c

1076

if (!server->io_stats) {

fs/nfs/client.c

1077

kfree(server);

fs/nfs/client.c

1081

server->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;

fs/nfs/client.c

1083

init_waitqueue_head(&server->write_congestion_wait);

fs/nfs/client.c

1084

atomic_long_set(&server->writeback, 0);

fs/nfs/client.c

1086

atomic64_set(&server->owner_ctr, 0);

fs/nfs/client.c

1088

pnfs_init_server(server);

fs/nfs/client.c

1089

rpc_init_wait_queue(&server->uoc_rpcwaitq, "NFS UOC");

fs/nfs/client.c

1091

return server;

fs/nfs/client.c

1097

struct nfs_server *server = container_of(p, struct nfs_server, rcu);

fs/nfs/client.c

1099

nfs_free_iostats(server->io_stats);

fs/nfs/client.c

1100

kfree(server);

fs/nfs/client.c

1106

void nfs_free_server(struct nfs_server *server)

fs/nfs/client.c

1108

nfs_server_remove_lists(server);

fs/nfs/client.c

1110

if (server->destroy != NULL)

fs/nfs/client.c

1111

server->destroy(server);

fs/nfs/client.c

1113

if (!IS_ERR(server->client_acl))

fs/nfs/client.c

1114

rpc_shutdown_client(server->client_acl);

fs/nfs/client.c

1115

if (!IS_ERR(server->client))

fs/nfs/client.c

1116

rpc_shutdown_client(server->client);

fs/nfs/client.c

1118

nfs_put_client(server->nfs_client);

fs/nfs/client.c

1120

if (server->kobj.state_initialized) {

fs/nfs/client.c

1121

nfs_sysfs_remove_server(server);

fs/nfs/client.c

1122

kobject_put(&server->kobj);

fs/nfs/client.c

1124

ida_free(&s_sysfs_ids, server->s_sysfs_id);

fs/nfs/client.c

1126

put_cred(server->cred);

fs/nfs/client.c

1128

call_rcu(&server->rcu, delayed_free);

fs/nfs/client.c

1139

struct nfs_server *server;

fs/nfs/client.c

1143

server = nfs_alloc_server();

fs/nfs/client.c

1144

if (!server)

fs/nfs/client.c

1147

server->cred = get_cred(fc->cred);

fs/nfs/client.c

1155

error = nfs_init_server(server, fc);

fs/nfs/client.c

1160

error = nfs_probe_fsinfo(server, ctx->mntfh, fattr);

fs/nfs/client.c

1163

if (server->nfs_client->rpc_ops->version == 3) {

fs/nfs/client.c

1164

if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)

fs/nfs/client.c

1165

server->namelen = NFS3_MAXNAMLEN;

fs/nfs/client.c

1167

server->caps |= NFS_CAP_READDIRPLUS;

fs/nfs/client.c

1169

if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)

fs/nfs/client.c

1170

server->namelen = NFS2_MAXNAMLEN;

fs/nfs/client.c

1173

server->fh_expire_type = NFS_FH_VOL_RENAME;

fs/nfs/client.c

1176

error = ctx->nfs_mod->rpc_ops->getattr(server, ctx->mntfh,

fs/nfs/client.c

1183

memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));

fs/nfs/client.c

1186

(unsigned long long) server->fsid.major,

fs/nfs/client.c

1187

(unsigned long long) server->fsid.minor);

fs/nfs/client.c

1189

nfs_server_insert_lists(server);

fs/nfs/client.c

1190

server->mount_time = jiffies;

fs/nfs/client.c

1192

return server;

fs/nfs/client.c

1196

nfs_free_server(server);

fs/nfs/client.c

1209

struct nfs_server *server;

fs/nfs/client.c

1212

server = nfs_alloc_server();

fs/nfs/client.c

1213

if (!server)

fs/nfs/client.c

1216

server->cred = get_cred(source->cred);

fs/nfs/client.c

1219

server->nfs_client = source->nfs_client;

fs/nfs/client.c

1220

server->destroy = source->destroy;

fs/nfs/client.c

1221

refcount_inc(&server->nfs_client->cl_count);

fs/nfs/client.c

1222

nfs_server_copy_userdata(server, source);

fs/nfs/client.c

1224

server->fsid = fattr->fsid;

fs/nfs/client.c

1226

nfs_sysfs_add_server(server);

fs/nfs/client.c

1228

nfs_sysfs_link_rpc_client(server,

fs/nfs/client.c

1229

server->nfs_client->cl_rpcclient, "_state");

fs/nfs/client.c

1231

error = nfs_init_server_rpcclient(server,

fs/nfs/client.c

1237

nfs_server_set_init_caps(server);

fs/nfs/client.c

1240

error = nfs_probe_server(server, fh);

fs/nfs/client.c

1244

if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)

fs/nfs/client.c

1245

server->namelen = NFS4_MAXNAMLEN;

fs/nfs/client.c

1247

error = nfs_start_lockd(server);

fs/nfs/client.c

1251

nfs_server_insert_lists(server);

fs/nfs/client.c

1252

server->mount_time = jiffies;

fs/nfs/client.c

1254

return server;

fs/nfs/client.c

1257

nfs_free_server(server);

fs/nfs/client.c

1425

struct nfs_server *server;

fs/nfs/client.c

1438

server = list_entry(v, struct nfs_server, master_link);

fs/nfs/client.c

1439

clp = server->nfs_client;

fs/nfs/client.c

1442

MAJOR(server->s_dev), MINOR(server->s_dev));

fs/nfs/client.c

1445

(unsigned long long) server->fsid.major,

fs/nfs/client.c

1446

(unsigned long long) server->fsid.minor);

fs/nfs/client.c

1455

nfs_server_fscache_state(server));

fs/nfs/client.c

222

static void pnfs_init_server(struct nfs_server *server)

fs/nfs/client.c

224

rpc_init_wait_queue(&server->roc_rpcwaitq, "pNFS ROC");

fs/nfs/client.c

236

static void pnfs_init_server(struct nfs_server *server)

fs/nfs/client.c

580

static void nfs_destroy_server(struct nfs_server *server)

fs/nfs/client.c

582

if (server->nlm_host)

fs/nfs/client.c

583

nlmclnt_done(server->nlm_host);

fs/nfs/client.c

589

static int nfs_start_lockd(struct nfs_server *server)

fs/nfs/client.c

592

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

598

.noresvport = server->flags & NFS_MOUNT_NORESVPORT ?

fs/nfs/client.c

602

.cred = server->cred,

fs/nfs/client.c

607

if ((server->flags & NFS_MOUNT_LOCAL_FLOCK) &&

fs/nfs/client.c

608

(server->flags & NFS_MOUNT_LOCAL_FCNTL))

fs/nfs/client.c

625

server->nlm_host = host;

fs/nfs/client.c

626

server->destroy = nfs_destroy_server;

fs/nfs/client.c

627

nfs_sysfs_link_rpc_client(server, nlmclnt_rpc_clnt(host), NULL);

fs/nfs/client.c

634

int nfs_init_server_rpcclient(struct nfs_server *server,

fs/nfs/client.c

638

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

640

server->client = rpc_clone_client_set_auth(clp->cl_rpcclient,

fs/nfs/client.c

642

if (IS_ERR(server->client)) {

fs/nfs/client.c

644

return PTR_ERR(server->client);

fs/nfs/client.c

647

memcpy(&server->client->cl_timeout_default,

fs/nfs/client.c

649

sizeof(server->client->cl_timeout_default));

fs/nfs/client.c

650

server->client->cl_timeout = &server->client->cl_timeout_default;

fs/nfs/client.c

651

server->client->cl_softrtry = 0;

fs/nfs/client.c

652

if (server->flags & NFS_MOUNT_SOFTERR)

fs/nfs/client.c

653

server->client->cl_softerr = 1;

fs/nfs/client.c

654

if (server->flags & NFS_MOUNT_SOFT)

fs/nfs/client.c

655

server->client->cl_softrtry = 1;

fs/nfs/client.c

657

nfs_sysfs_link_rpc_client(server, server->client, NULL);

fs/nfs/client.c

693

static void nfs4_server_set_init_caps(struct nfs_server *server)

fs/nfs/client.c

697

server->caps = server->nfs_client->cl_mvops->init_caps;

fs/nfs/client.c

698

if (server->flags & NFS_MOUNT_NORDIRPLUS)

fs/nfs/client.c

699

server->caps &= ~NFS_CAP_READDIRPLUS;

fs/nfs/client.c

700

if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA)

fs/nfs/client.c

701

server->caps &= ~NFS_CAP_READ_PLUS;

fs/nfs/client.c

708

server->client->cl_auth->au_flavor == RPC_AUTH_UNIX)

fs/nfs/client.c

709

server->caps |= NFS_CAP_UIDGID_NOMAP;

fs/nfs/client.c

713

void nfs_server_set_init_caps(struct nfs_server *server)

fs/nfs/client.c

715

switch (server->nfs_client->rpc_ops->version) {

fs/nfs/client.c

717

server->caps = NFS_CAP_HARDLINKS | NFS_CAP_SYMLINKS;

fs/nfs/client.c

720

server->caps = NFS_CAP_HARDLINKS | NFS_CAP_SYMLINKS;

fs/nfs/client.c

721

if (!(server->flags & NFS_MOUNT_NORDIRPLUS))

fs/nfs/client.c

722

server->caps |= NFS_CAP_READDIRPLUS;

fs/nfs/client.c

725

nfs4_server_set_init_caps(server);

fs/nfs/client.c

734

static int nfs_init_server(struct nfs_server *server,

fs/nfs/client.c

747

.cred = server->cred,

fs/nfs/client.c

768

server->nfs_client = clp;

fs/nfs/client.c

769

nfs_sysfs_add_server(server);

fs/nfs/client.c

770

nfs_sysfs_link_rpc_client(server, clp->cl_rpcclient, "_state");

fs/nfs/client.c

773

server->flags = ctx->flags;

fs/nfs/client.c

774

server->options = ctx->options;

fs/nfs/client.c

778

server->fattr_valid = NFS_ATTR_FATTR_V2;

fs/nfs/client.c

781

server->fattr_valid = NFS_ATTR_FATTR_V3;

fs/nfs/client.c

784

server->fattr_valid = NFS_ATTR_FATTR_V4;

fs/nfs/client.c

788

server->bsize = ctx->bsize;

fs/nfs/client.c

789

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_BSIZE;

fs/nfs/client.c

792

server->rsize = nfs_io_size(ctx->rsize, clp->cl_proto);

fs/nfs/client.c

793

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_RSIZE;

fs/nfs/client.c

796

server->wsize = nfs_io_size(ctx->wsize, clp->cl_proto);

fs/nfs/client.c

797

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_WSIZE;

fs/nfs/client.c

800

server->acregmin = ctx->acregmin * HZ;

fs/nfs/client.c

801

server->acregmax = ctx->acregmax * HZ;

fs/nfs/client.c

802

server->acdirmin = ctx->acdirmin * HZ;

fs/nfs/client.c

803

server->acdirmax = ctx->acdirmax * HZ;

fs/nfs/client.c

806

error = nfs_start_lockd(server);

fs/nfs/client.c

810

server->port = ctx->nfs_server.port;

fs/nfs/client.c

811

server->auth_info = ctx->auth_info;

fs/nfs/client.c

813

error = nfs_init_server_rpcclient(server, &timeparms,

fs/nfs/client.c

818

nfs_server_set_init_caps(server);

fs/nfs/client.c

822

memcpy(&server->mountd_address, &ctx->mount_server.address,

fs/nfs/client.c

824

server->mountd_addrlen = ctx->mount_server.addrlen;

fs/nfs/client.c

826

server->mountd_version = ctx->mount_server.version;

fs/nfs/client.c

827

server->mountd_port = ctx->mount_server.port;

fs/nfs/client.c

828

server->mountd_protocol = ctx->mount_server.protocol;

fs/nfs/client.c

830

server->namelen = ctx->namlen;

fs/nfs/client.c

834

server->nfs_client = NULL;

fs/nfs/client.c

842

static void nfs_server_set_fsinfo(struct nfs_server *server,

fs/nfs/client.c

845

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

849

if (server->rsize == 0)

fs/nfs/client.c

850

server->rsize = nfs_io_size(fsinfo->rtpref, clp->cl_proto);

fs/nfs/client.c

851

if (server->wsize == 0)

fs/nfs/client.c

852

server->wsize = nfs_io_size(fsinfo->wtpref, clp->cl_proto);

fs/nfs/client.c

854

if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)

fs/nfs/client.c

855

server->rsize = nfs_io_size(fsinfo->rtmax, clp->cl_proto);

fs/nfs/client.c

856

if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)

fs/nfs/client.c

857

server->wsize = nfs_io_size(fsinfo->wtmax, clp->cl_proto);

fs/nfs/client.c

859

raw_max_rpc_payload = rpc_max_payload(server->client);

fs/nfs/client.c

862

if (server->rsize > max_rpc_payload)

fs/nfs/client.c

863

server->rsize = max_rpc_payload;

fs/nfs/client.c

864

if (server->rsize > NFS_MAX_FILE_IO_SIZE)

fs/nfs/client.c

865

server->rsize = NFS_MAX_FILE_IO_SIZE;

fs/nfs/client.c

866

server->rpages = (server->rsize + PAGE_SIZE - 1) >> PAGE_SHIFT;

fs/nfs/client.c

868

if (server->wsize > max_rpc_payload)

fs/nfs/client.c

869

server->wsize = max_rpc_payload;

fs/nfs/client.c

870

if (server->wsize > NFS_MAX_FILE_IO_SIZE)

fs/nfs/client.c

871

server->wsize = NFS_MAX_FILE_IO_SIZE;

fs/nfs/client.c

873

server->wtmult = nfs_block_bits(fsinfo->wtmult, NULL);

fs/nfs/client.c

875

server->dtsize = nfs_block_size(fsinfo->dtpref, NULL);

fs/nfs/client.c

876

if (server->dtsize > NFS_MAX_FILE_IO_SIZE)

fs/nfs/client.c

877

server->dtsize = NFS_MAX_FILE_IO_SIZE;

fs/nfs/client.c

878

if (server->dtsize > server->rsize)

fs/nfs/client.c

879

server->dtsize = server->rsize;

fs/nfs/client.c

881

if (server->flags & NFS_MOUNT_NOAC) {

fs/nfs/client.c

882

server->acregmin = server->acregmax = 0;

fs/nfs/client.c

883

server->acdirmin = server->acdirmax = 0;

fs/nfs/client.c

886

server->maxfilesize = fsinfo->maxfilesize;

fs/nfs/client.c

888

server->change_attr_type = fsinfo->change_attr_type;

fs/nfs/client.c

890

server->clone_blksize = fsinfo->clone_blksize;

fs/nfs/client.c

892

rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);

fs/nfs/client.c

898

server->gxasize = min_t(unsigned int, raw_max_rpc_payload,

fs/nfs/client.c

900

server->sxasize = min_t(unsigned int, raw_max_rpc_payload,

fs/nfs/client.c

902

server->lxasize = min_t(unsigned int, raw_max_rpc_payload,

fs/nfs/client.c

906

server->caps |= NFS_CAP_XATTR;

fs/nfs/client.c

908

server->caps &= ~NFS_CAP_XATTR;

fs/nfs/client.c

915

static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)

fs/nfs/client.c

918

struct nfs_client *clp = server->nfs_client;

fs/nfs/client.c

922

error = clp->rpc_ops->set_capabilities(server, mntfh);

fs/nfs/client.c

930

error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);

fs/nfs/client.c

934

nfs_server_set_fsinfo(server, &fsinfo);

fs/nfs/client.c

937

if (server->namelen == 0) {

fs/nfs/client.c

943

if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)

fs/nfs/client.c

944

server->namelen = pathinfo.max_namelen;

fs/nfs/client.c

948

(server->caps & NFS_CAP_FS_LOCATIONS &&

fs/nfs/client.c

949

(server->flags & NFS_MOUNT_TRUNK_DISCOVERY))) {

fs/nfs/client.c

950

error = clp->rpc_ops->discover_trunking(server, mntfh);

fs/nfs/client.c

964

int nfs_probe_server(struct nfs_server *server, struct nfs_fh *mntfh)

fs/nfs/client.c

975

error = nfs_probe_fsinfo(server, mntfh, fattr);

fs/nfs/delegation.c

1002

nfs_mark_return_if_closed_delegation(server, delegation);

fs/nfs/delegation.c

1008

struct nfs_server *server;

fs/nfs/delegation.c

101

set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);

fs/nfs/delegation.c

1011

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

1012

nfs_mark_return_unused_delegation_types(server, flags);

fs/nfs/delegation.c

1112

static bool nfs_mark_return_unreferenced_delegations(struct nfs_server *server)

fs/nfs/delegation.c

1117

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

1118

list_for_each_entry_safe(d, n, &server->delegations_lru, entry) {

fs/nfs/delegation.c

1121

list_move_tail(&d->entry, &server->delegations_return);

fs/nfs/delegation.c

1124

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

1136

struct nfs_server *server;

fs/nfs/delegation.c

1140

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

1141

marked |= nfs_mark_return_unreferenced_delegations(server);

fs/nfs/delegation.c

1160

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

1161

struct nfs_client *clp = server->nfs_client;

fs/nfs/delegation.c

1174

nfs_mark_return_delegation(server, delegation);

fs/nfs/delegation.c

1185

nfs_delegation_find_inode_server(struct nfs_server *server,

fs/nfs/delegation.c

1188

struct hlist_head *head = nfs_delegation_hash(server, fhandle);

fs/nfs/delegation.c

1198

if (nfs_sb_active(server->super)) {

fs/nfs/delegation.c

1199

freeme = server->super;

fs/nfs/delegation.c

1228

struct nfs_server *server;

fs/nfs/delegation.c

1232

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/delegation.c

1233

res = nfs_delegation_find_inode_server(server, fhandle);

fs/nfs/delegation.c

1243

static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)

fs/nfs/delegation.c

1247

list_for_each_entry_rcu(delegation, &server->delegations, super_list) {

fs/nfs/delegation.c

1265

struct nfs_server *server;

fs/nfs/delegation.c

1268

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

1269

nfs_delegation_mark_reclaim_server(server);

fs/nfs/delegation.c

1273

static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,

fs/nfs/delegation.c

1280

list_for_each_entry_rcu(delegation, &server->delegations, super_list) {

fs/nfs/delegation.c

1293

server)) {

fs/nfs/delegation.c

1294

nfs_mark_delegation_revoked(server, delegation);

fs/nfs/delegation.c

1326

static void nfs_mark_test_expired_delegation(struct nfs_server *server,

fs/nfs/delegation.c

1333

set_bit(NFS4SERV_DELEGATION_EXPIRED, &server->delegation_flags);

fs/nfs/delegation.c

1334

set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);

fs/nfs/delegation.c

1337

static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,

fs/nfs/delegation.c

1345

nfs_mark_test_expired_delegation(server, delegation);

fs/nfs/delegation.c

1350

static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)

fs/nfs/delegation.c

1354

list_for_each_entry_rcu(delegation, &server->delegations, super_list)

fs/nfs/delegation.c

1355

nfs_mark_test_expired_delegation(server, delegation);

fs/nfs/delegation.c

1367

struct nfs_server *server;

fs/nfs/delegation.c

1370

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

1371

nfs_delegation_mark_test_expired_server(server);

fs/nfs/delegation.c

1392

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

1393

const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;

fs/nfs/delegation.c

1398

status = ops->test_and_free_expired(server, stateid, cred);

fs/nfs/delegation.c

1403

static int nfs_server_reap_expired_delegations(struct nfs_server *server,

fs/nfs/delegation.c

1410

unsigned long gen = ++server->delegation_gen;

fs/nfs/delegation.c

1413

&server->delegation_flags))

fs/nfs/delegation.c

1417

list_for_each_entry_rcu(delegation, &server->delegations, super_list) {

fs/nfs/delegation.c

1436

if (!nfs4_server_rebooted(server->nfs_client)) {

fs/nfs/delegation.c

1441

nfs_inode_mark_test_expired_delegation(server,inode);

fs/nfs/delegation.c

1442

set_bit(NFS4SERV_DELEGATION_EXPIRED, &server->delegation_flags);

fs/nfs/delegation.c

1444

&server->nfs_client->cl_state);

fs/nfs/delegation.c

1496

struct nfs_server *server;

fs/nfs/delegation.c

1500

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

1501

if (atomic_long_read(&server->nr_active_delegations) > 0) {

fs/nfs/delegation.c

1599

int nfs4_delegation_hash_alloc(struct nfs_server *server)

fs/nfs/delegation.c

1604

server->delegation_hash_mask = delegation_buckets - 1;

fs/nfs/delegation.c

1605

server->delegation_hash_table = kmalloc_objs(*server->delegation_hash_table,

fs/nfs/delegation.c

1607

if (!server->delegation_hash_table)

fs/nfs/delegation.c

1610

INIT_HLIST_HEAD(&server->delegation_hash_table[i]);

fs/nfs/delegation.c

376

struct nfs_server *server)

fs/nfs/delegation.c

378

struct nfs_client *clp = server->nfs_client;

fs/nfs/delegation.c

38

static struct hlist_head *nfs_delegation_hash(struct nfs_server *server,

fs/nfs/delegation.c

404

nfs_update_inplace_delegation(struct nfs_server *server,

fs/nfs/delegation.c

41

return server->delegation_hash_table +

fs/nfs/delegation.c

418

atomic_long_inc(&server->nr_active_delegations);

fs/nfs/delegation.c

42

(nfs_fhandle_hash(fhandle) & server->delegation_hash_mask);

fs/nfs/delegation.c

438

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

439

struct nfs_client *clp = server->nfs_client;

fs/nfs/delegation.c

474

nfs_update_inplace_delegation(server, old_delegation,

fs/nfs/delegation.c

519

list_add_tail_rcu(&delegation->super_list, &server->delegations);

fs/nfs/delegation.c

52

static void nfs_mark_delegation_revoked(struct nfs_server *server,

fs/nfs/delegation.c

521

nfs_delegation_hash(server, &NFS_I(inode)->fh));

fs/nfs/delegation.c

525

atomic_long_inc(&server->nr_active_delegations);

fs/nfs/delegation.c

539

nfs_mark_delegation_revoked(server, freeme);

fs/nfs/delegation.c

553

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

581

err = nfs4_wait_clnt_recover(server->nfs_client);

fs/nfs/delegation.c

587

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

590

list_move_tail(&delegation->entry, &server->delegations_return);

fs/nfs/delegation.c

591

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

592

set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &server->nfs_client->cl_state);

fs/nfs/delegation.c

598

static int nfs_return_one_delegation(struct nfs_server *server)

fs/nfs/delegation.c

604

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

605

delegation = list_first_entry_or_null(&server->delegations_return,

fs/nfs/delegation.c

608

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

61

atomic_long_dec(&server->nr_active_delegations);

fs/nfs/delegation.c

612

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

640

static int nfs_server_return_marked_delegations(struct nfs_server *server,

fs/nfs/delegation.c

645

while ((err = nfs_return_one_delegation(server)) > 0)

fs/nfs/delegation.c

65

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

650

static inline bool nfs_delegations_over_limit(struct nfs_server *server)

fs/nfs/delegation.c

652

return !list_empty_careful(&server->delegations_lru) &&

fs/nfs/delegation.c

653

atomic_long_read(&server->nr_active_delegations) >

fs/nfs/delegation.c

657

static void nfs_delegations_return_from_lru(struct nfs_server *server)

fs/nfs/delegation.c

664

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

665

list_for_each_entry_safe(d, n, &server->delegations_lru, entry) {

fs/nfs/delegation.c

666

if (!nfs_delegations_over_limit(server))

fs/nfs/delegation.c

670

list_move_tail(&d->entry, &server->delegations_return);

fs/nfs/delegation.c

673

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

679

if (pass == 0 && nfs_delegations_over_limit(server)) {

fs/nfs/delegation.c

685

set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);

fs/nfs/delegation.c

686

nfs4_schedule_state_manager(server->nfs_client);

fs/nfs/delegation.c

690

static void nfs_delegation_add_lru(struct nfs_server *server,

fs/nfs/delegation.c

693

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

695

list_add_tail(&delegation->entry, &server->delegations_lru);

fs/nfs/delegation.c

698

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

70

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

700

if (nfs_delegations_over_limit(server))

fs/nfs/delegation.c

701

nfs_delegations_return_from_lru(server);

fs/nfs/delegation.c

704

static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)

fs/nfs/delegation.c

708

if (list_empty_careful(&server->delegations_delayed))

fs/nfs/delegation.c

711

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

712

if (!list_empty(&server->delegations_delayed)) {

fs/nfs/delegation.c

713

list_splice_tail_init(&server->delegations_delayed,

fs/nfs/delegation.c

714

&server->delegations_return);

fs/nfs/delegation.c

717

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

724

struct nfs_server *server;

fs/nfs/delegation.c

731

list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {

fs/nfs/delegation.c

732

if (nfs_server_clear_delayed_delegations(server))

fs/nfs/delegation.c

775

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

780

if (delegation && !nfs_detach_delegation(nfsi, delegation, server))

fs/nfs/delegation.c

789

nfs_mark_delegation_revoked(server, delegation);

fs/nfs/delegation.c

866

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/delegation.c

889

nfs_delegation_add_lru(server, delegation);

fs/nfs/delegation.c

915

nfs_mark_return_if_closed_delegation(struct nfs_server *server,

fs/nfs/delegation.c

92

static void nfs_mark_return_delegation(struct nfs_server *server,

fs/nfs/delegation.c

920

if (!list_empty_careful(&server->delegations_return) ||

fs/nfs/delegation.c

928

nfs_mark_return_delegation(server, delegation);

fs/nfs/delegation.c

935

static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)

fs/nfs/delegation.c

940

list_for_each_entry_rcu(delegation, &server->delegations, super_list) {

fs/nfs/delegation.c

941

nfs_mark_return_delegation(server, delegation);

fs/nfs/delegation.c

95

spin_lock(&server->delegations_lock);

fs/nfs/delegation.c

960

struct nfs_server *server;

fs/nfs/delegation.c

963

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/delegation.c

964

nfs_server_mark_return_all_delegations(server);

fs/nfs/delegation.c

975

void nfs_server_return_all_delegations(struct nfs_server *server)

fs/nfs/delegation.c

977

struct nfs_client *clp = server->nfs_client;

fs/nfs/delegation.c

98

list_move_tail(&delegation->entry, &server->delegations_return);

fs/nfs/delegation.c

984

need_wait = nfs_server_mark_return_all_delegations(server);

fs/nfs/delegation.c

99

spin_unlock(&server->delegations_lock);

fs/nfs/delegation.c

993

static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,

fs/nfs/delegation.c

998

list_for_each_entry_rcu(delegation, &server->delegations, super_list) {

fs/nfs/delegation.h

139

int nfs4_delegation_hash_alloc(struct nfs_server *server);

fs/nfs/dir.c

1595

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/dir.c

1605

if (server->caps & NFS_CAP_ATOMIC_OPEN)

fs/nfs/dir.c

1609

if (server->flags & NFS_MOUNT_NOCTO)

fs/nfs/dir.c

1629

ret = __nfs_revalidate_inode(server, inode);

fs/nfs/dir.c

183

struct nfs_server *server = NFS_SERVER(file_inode(desc->file));

fs/nfs/dir.c

184

unsigned int maxsize = server->dtsize;

fs/nfs/dir.c

2149

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/dir.c

2151

if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))

fs/nfs/dir.c

2358

struct nfs_server *server = NFS_SB(dentry->d_sb);

fs/nfs/dir.c

2359

error = server->nfs_client->rpc_ops->getattr(server, fhandle,

fs/nfs/dir.c

2723

struct nfs_server *server = NFS_SB(old_dentry->d_sb);

fs/nfs/dir.c

2727

if (server->fh_expire_type & NFS_FH_RENAME_UNSAFE)

fs/nfs/dir.c

2728

return !(server->fh_expire_type & NFS_FH_NOEXPIRE_WITH_OPEN);

fs/nfs/dir.c

3361

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/dir.c

3369

ret = __nfs_revalidate_inode(server, inode);

fs/nfs/dir.c

951

entry->server = NFS_SERVER(inode);

fs/nfs/export.c

129

struct nfs_server *server = NFS_SB(sb);

fs/nfs/export.c

132

struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;

fs/nfs/export.c

138

fattr = nfs_alloc_fattr_with_label(server);

fs/nfs/file.c

105

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/file.c

113

return __nfs_revalidate_inode(server, inode);

fs/nfs/filelayout/filelayout.c

1030

filelayout_alloc_deviceid_node(struct nfs_server *server,

fs/nfs/filelayout/filelayout.c

1035

dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags);

fs/nfs/filelayout/filelayout.h

113

nfs4_fl_alloc_deviceid_node(struct nfs_server *server,

fs/nfs/filelayout/filelayoutdev.c

149

nfs4_init_deviceid_node(&dsaddr->id_node, server, &pdev->dev_id);

fs/nfs/filelayout/filelayoutdev.c

176

trace_fl_getdevinfo(server, &pdev->dev_id, dsaddr->ds_list[i]->ds_remotestr);

fs/nfs/filelayout/filelayoutdev.c

64

nfs4_fl_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,

fs/nfs/filelayout/filelayoutdev.c

79

struct net *net = server->nfs_client->cl_net;

fs/nfs/flexfilelayout/flexfilelayout.c

2563

ff_layout_alloc_deviceid_node(struct nfs_server *server,

fs/nfs/flexfilelayout/flexfilelayout.c

2568

dsaddr = nfs4_ff_alloc_deviceid_node(server, pdev, gfp_flags);

fs/nfs/flexfilelayout/flexfilelayout.c

2968

ff_layout_set_layoutdriver(struct nfs_server *server,

fs/nfs/flexfilelayout/flexfilelayout.c

2972

server->caps |= NFS_CAP_LAYOUTSTATS | NFS_CAP_REBOOT_LAYOUTRETURN;

fs/nfs/flexfilelayout/flexfilelayout.h

213

nfs4_ff_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,

fs/nfs/flexfilelayout/flexfilelayoutdev.c

116

server->nfs_client->cl_proto);

fs/nfs/flexfilelayout/flexfilelayoutdev.c

118

server->nfs_client->cl_proto);

fs/nfs/flexfilelayout/flexfilelayoutdev.c

42

nfs4_ff_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,

fs/nfs/flexfilelayout/flexfilelayoutdev.c

52

struct net *net = server->nfs_client->cl_net;

fs/nfs/flexfilelayout/flexfilelayoutdev.c

68

server,

fs/nfs/fs_context.c

1662

if (ctx->server)

fs/nfs/fs_context.c

1663

nfs_free_server(ctx->server);

fs/nfs/fscache.h

141

static inline const char *nfs_server_fscache_state(struct nfs_server *server)

fs/nfs/fscache.h

143

if (server->fscache)

fs/nfs/fscache.h

192

static inline const char *nfs_server_fscache_state(struct nfs_server *server)

fs/nfs/getroot.c

127

if (server->caps & NFS_CAP_SECURITY_LABEL)

fs/nfs/getroot.c

140

server->has_sec_mnt_opts = clone_server->has_sec_mnt_opts;

fs/nfs/getroot.c

147

if (server->caps & NFS_CAP_SECURITY_LABEL &&

fs/nfs/getroot.c

149

server->caps &= ~NFS_CAP_SECURITY_LABEL;

fs/nfs/getroot.c

70

struct nfs_server *server = NFS_SB(s), *clone_server;

fs/nfs/getroot.c

83

fsinfo.fattr = nfs_alloc_fattr_with_label(server);

fs/nfs/getroot.c

87

error = server->nfs_client->rpc_ops->getroot(server, ctx->mntfh, &fsinfo);

fs/nfs/inode.c

1065

err = __nfs_revalidate_inode(server, inode);

fs/nfs/inode.c

1078

if (server->change_attr_type != NFS4_CHANGE_TYPE_IS_UNDEFINED)

fs/nfs/inode.c

1372

__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)

fs/nfs/inode.c

1405

status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);

fs/nfs/inode.c

1413

if (server->flags & NFS_MOUNT_SOFTREVAL)

fs/nfs/inode.c

1789

struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)

fs/nfs/inode.c

1796

fattr->label = nfs4_label_alloc(server, GFP_KERNEL);

fs/nfs/inode.c

2249

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/inode.c

2252

u64 fattr_supported = server->fattr_valid;

fs/nfs/inode.c

2298

!nfs_fsid_equal(&server->fsid, &fattr->fsid) &&

fs/nfs/inode.c

2300

server->fsid = fattr->fsid;

fs/nfs/inode.c

379

struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)

fs/nfs/inode.c

383

if (!(server->caps & NFS_CAP_SECURITY_LABEL))

fs/nfs/inode.c

986

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/inode.c

987

u64 fattr_valid = server->fattr_valid;

fs/nfs/internal.h

147

struct nfs_server *server;

fs/nfs/internal.h

236

extern int nfs4_update_server(struct nfs_server *server, const char *hostname,

fs/nfs/internal.h

239

extern void nfs_free_server(struct nfs_server *server);

fs/nfs/internal.h

346

extern struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags);

fs/nfs/internal.h

370

static inline struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) { return NULL; }

fs/nfs/internal.h

410

static inline __u32 nfs_access_xattr_mask(const struct nfs_server *server)

fs/nfs/internal.h

412

if (!(server->caps & NFS_CAP_XATTR))

fs/nfs/internal.h

417

static inline __u32 nfs_access_xattr_mask(const struct nfs_server *server)

fs/nfs/internal.h

561

extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);

fs/nfs/iostat.h

23

static inline void nfs_inc_server_stats(const struct nfs_server *server,

fs/nfs/iostat.h

26

this_cpu_inc(server->io_stats->events[stat]);

fs/nfs/iostat.h

35

static inline void nfs_add_server_stats(const struct nfs_server *server,

fs/nfs/iostat.h

39

this_cpu_add(server->io_stats->bytes[stat], addend);

fs/nfs/namespace.c

150

struct nfs_server *server = NFS_SB(path->dentry->d_sb);

fs/nfs/namespace.c

151

struct nfs_client *client = server->nfs_client;

fs/nfs/namespace.c

173

if (fc->cred != server->cred) {

fs/nfs/namespace.c

175

fc->cred = get_cred(server->cred);

fs/nfs/namespace.c

191

ctx->nfs_server.port = server->port;

fs/nfs/namespace.c

199

if (server->automount_inherit & NFS_AUTOMOUNT_INHERIT_BSIZE)

fs/nfs/namespace.c

200

ctx->bsize = server->bsize;

fs/nfs/namespace.c

202

ret = client->rpc_ops->submount(fc, server);

fs/nfs/namespace.c

281

struct nfs_server *server;

fs/nfs/namespace.c

286

server = ctx->nfs_mod->rpc_ops->clone_server(NFS_SB(ctx->clone_data.sb),

fs/nfs/namespace.c

291

if (IS_ERR(server))

fs/nfs/namespace.c

292

return PTR_ERR(server);

fs/nfs/namespace.c

294

ctx->server = server;

fs/nfs/namespace.c

317

int nfs_submount(struct fs_context *fc, struct nfs_server *server)

fs/nfs/namespace.c

325

err = server->nfs_client->rpc_ops->lookup(d_inode(parent), dentry, &dentry->d_name,

fs/nfs/namespace.c

331

ctx->selected_flavor = server->client->cl_auth->au_flavor;

fs/nfs/nfs3acl.c

112

server->caps &= ~NFS_CAP_ACLS;

fs/nfs/nfs3acl.c

164

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs3acl.c

218

msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_SETACL];

fs/nfs/nfs3acl.c

220

status = rpc_call_sync(server->client_acl, &msg, 0);

fs/nfs/nfs3acl.c

233

server->caps &= ~NFS_CAP_ACLS;

fs/nfs/nfs3acl.c

48

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs3acl.c

88

msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_GETACL];

fs/nfs/nfs3acl.c

98

status = rpc_call_sync(server->client_acl, &msg, 0);

fs/nfs/nfs3client.c

28

static void nfs_init_server_aclclient(struct nfs_server *server)

fs/nfs/nfs3client.c

30

if (server->flags & NFS_MOUNT_NOACL)

fs/nfs/nfs3client.c

33

server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);

fs/nfs/nfs3client.c

34

if (IS_ERR(server->client_acl))

fs/nfs/nfs3client.c

37

nfs_sysfs_link_rpc_client(server, server->client_acl, NULL);

fs/nfs/nfs3client.c

40

server->caps |= NFS_CAP_ACLS;

fs/nfs/nfs3client.c

44

server->caps &= ~NFS_CAP_ACLS;

fs/nfs/nfs3client.c

47

static inline void nfs_init_server_aclclient(struct nfs_server *server)

fs/nfs/nfs3client.c

49

server->flags &= ~NFS_MOUNT_NOACL;

fs/nfs/nfs3client.c

50

server->caps &= ~NFS_CAP_ACLS;

fs/nfs/nfs3client.c

56

struct nfs_server *server = nfs_create_server(fc);

fs/nfs/nfs3client.c

59

if (!IS_ERR(server))

fs/nfs/nfs3client.c

60

nfs_init_server_aclclient(server);

fs/nfs/nfs3client.c

61

return server;

fs/nfs/nfs3client.c

69

struct nfs_server *server = nfs_clone_server(source, fh, fattr, flavor);

fs/nfs/nfs3client.c

70

if (!IS_ERR(server) && !IS_ERR(source->client_acl))

fs/nfs/nfs3client.c

71

nfs_init_server_aclclient(server);

fs/nfs/nfs3client.c

72

return server;

fs/nfs/nfs3proc.c

103

nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs3proc.c

115

if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))

fs/nfs/nfs3proc.c

120

status = rpc_call_sync(server->client, &msg, task_flags);

fs/nfs/nfs3proc.c

786

nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs3proc.c

798

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/nfs3proc.c

826

nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs3proc.c

831

status = do_proc_fsinfo(server->client, fhandle, info);

fs/nfs/nfs3proc.c

832

if (status && server->nfs_client->cl_rpcclient != server->client)

fs/nfs/nfs3proc.c

833

status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);

fs/nfs/nfs3proc.c

838

nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs3proc.c

850

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/nfs3proc.c

862

static void nfs3_localio_probe(struct nfs_server *server)

fs/nfs/nfs3proc.c

864

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs3proc.c

88

nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs3proc.c

887

static void nfs3_localio_probe(struct nfs_server *server) {}

fs/nfs/nfs3proc.c

893

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs3proc.c

902

if (!server->read_hdrsize)

fs/nfs/nfs3proc.c

903

cmpxchg(&server->read_hdrsize, 0, hdr->res.replen);

fs/nfs/nfs3proc.c

904

nfs3_localio_probe(server);

fs/nfs/nfs3proc.c

93

status = do_proc_get_root(server->client, fhandle, info);

fs/nfs/nfs3proc.c

94

if (status && server->nfs_client->cl_rpcclient != server->client)

fs/nfs/nfs3proc.c

95

status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);

fs/nfs/nfs3xdr.c

1967

struct user_namespace *userns = rpc_userns(entry->server->client);

fs/nfs/nfs40proc.c

153

static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,

fs/nfs/nfs40proc.c

167

static int _nfs40_proc_get_locations(struct nfs_server *server,

fs/nfs/nfs40proc.c

172

struct rpc_clnt *clnt = server->client;

fs/nfs/nfs40proc.c

173

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs40proc.c

200

locations->server = server;

fs/nfs/nfs40proc.c

204

status = nfs4_call_sync_sequence(clnt, server, &msg,

fs/nfs/nfs40proc.c

209

renew_lease(server, now);

fs/nfs/nfs40proc.c

222

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs40proc.c

224

struct rpc_clnt *clnt = server->client;

fs/nfs/nfs40proc.c

247

status = nfs4_call_sync_sequence(clnt, server, &msg,

fs/nfs/nfs40proc.c

259

struct nfs_server *server;

fs/nfs/nfs40proc.c

268

struct nfs_server *server = data->server;

fs/nfs/nfs40proc.c

269

nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs40proc.c

271

data->args.lock_owner.clientid = server->nfs_client->cl_clientid;

fs/nfs/nfs40proc.c

278

struct nfs_server *server = data->server;

fs/nfs/nfs40proc.c

284

renew_lease(server, data->timestamp);

fs/nfs/nfs40proc.c

288

nfs4_schedule_lease_recovery(server->nfs_client);

fs/nfs/nfs40proc.c

292

if (nfs4_async_handle_error(task, server,

fs/nfs/nfs40proc.c

301

nfs4_free_lock_state(data->server, data->lsp);

fs/nfs/nfs40proc.c

312

nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)

fs/nfs/nfs40proc.c

315

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs40proc.c

327

data->server = server;

fs/nfs/nfs40proc.c

330

data->args.lock_owner.s_dev = server->s_dev;

fs/nfs/nfs40proc.c

335

rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);

fs/nfs/nfs42proc.c

105

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1053

int nfs42_proc_layoutstats_generic(struct nfs_server *server,

fs/nfs/nfs42proc.c

1062

.rpc_client = server->client,

fs/nfs/nfs42proc.c

1075

nfs4_init_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs42proc.c

1117

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1131

nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs42proc.c

1214

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1242

task_setup.rpc_client = server->client;

fs/nfs/nfs42proc.c

1243

nfs4_init_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs42proc.c

1260

struct nfs_server *server = NFS_SERVER(dst_inode);

fs/nfs/nfs42proc.c

127

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs42proc.c

1271

.server = server,

fs/nfs/nfs42proc.c

1298

nfs4_bitmask_set(dst_bitmask, server->cache_consistency_bitmask,

fs/nfs/nfs42proc.c

1301

status = nfs4_call_sync(server->client, server, msg,

fs/nfs/nfs42proc.c

1323

struct nfs_server *server = NFS_SERVER(file_inode(src_f));

fs/nfs/nfs42proc.c

1358

err2 = nfs4_handle_exception(server, err, &src_exception);

fs/nfs/nfs42proc.c

1359

err = nfs4_handle_exception(server, err, &dst_exception);

fs/nfs/nfs42proc.c

1374

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1388

ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,

fs/nfs/nfs42proc.c

1400

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1412

.server = server,

fs/nfs/nfs42proc.c

1422

if (buflen > server->sxasize)

fs/nfs/nfs42proc.c

1438

nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask,

fs/nfs/nfs42proc.c

1441

ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,

fs/nfs/nfs42proc.c

1462

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1478

ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,

fs/nfs/nfs42proc.c

1508

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

1534

if (xdrlen > server->lxasize)

fs/nfs/nfs42proc.c

1535

xdrlen = server->lxasize;

fs/nfs/nfs42proc.c

1550

ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,

fs/nfs/nfs42proc.c

50

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

517

struct nfs_server *server = NFS_SERVER(file_inode(dst));

fs/nfs/nfs42proc.c

589

err2 = nfs4_handle_exception(server, err, &src_exception);

fs/nfs/nfs42proc.c

59

.falloc_server = server,

fs/nfs/nfs42proc.c

590

err = nfs4_handle_exception(server, err, &dst_exception);

fs/nfs/nfs42proc.c

686

_nfs42_proc_offload_status(struct nfs_server *server, struct file *file,

fs/nfs/nfs42proc.c

698

status = nfs4_call_sync(server->client, server, &msg,

fs/nfs/nfs42proc.c

720

server->caps &= ~NFS_CAP_OFFLOAD_STATUS;

fs/nfs/nfs42proc.c

74

nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask, inode,

fs/nfs/nfs42proc.c

749

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

756

if (!(server->caps & NFS_CAP_OFFLOAD_STATUS))

fs/nfs/nfs42proc.c

762

data->seq_server = server;

fs/nfs/nfs42proc.c

768

status = _nfs42_proc_offload_status(server, dst, data);

fs/nfs/nfs42proc.c

771

status = nfs4_handle_exception(server, status, &exception);

fs/nfs/nfs42proc.c

81

status = nfs4_call_sync(server->client, server, msg,

fs/nfs/nfs42proc.c

880

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

899

status = nfs4_call_sync(server->client, server, &msg,

fs/nfs/nfs42proc.c

903

server->caps &= ~NFS_CAP_SEEK;

fs/nfs/nfs42proc.c

915

struct nfs_server *server = NFS_SERVER(file_inode(filep));

fs/nfs/nfs42proc.c

935

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs42proc.c

948

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs42proc.c

960

nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs42xdr.c

1691

decode_getfattr(xdr, res->dst_fattr, res->server);

fs/nfs/nfs42xdr.c

1745

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4_fs.h

300

int nfs4_replace_transport(struct nfs_server *server,

fs/nfs/nfs4_fs.h

313

struct nfs_server *server,

fs/nfs/nfs4_fs.h

319

struct nfs_server *server,

fs/nfs/nfs4_fs.h

327

extern void renew_lease(const struct nfs_server *server, unsigned long timestamp);

fs/nfs/nfs4_fs.h

336

extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);

fs/nfs/nfs4_fs.h

355

extern int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4_fs.h

381

extern int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4_fs.h

543

extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);

fs/nfs/nfs4client.c

1002

server->rsize =

fs/nfs/nfs4client.c

1003

nfs_io_size(ctx->rsize, server->nfs_client->cl_proto);

fs/nfs/nfs4client.c

1004

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_RSIZE;

fs/nfs/nfs4client.c

1007

server->wsize =

fs/nfs/nfs4client.c

1008

nfs_io_size(ctx->wsize, server->nfs_client->cl_proto);

fs/nfs/nfs4client.c

1009

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_WSIZE;

fs/nfs/nfs4client.c

1012

server->acregmin = ctx->acregmin * HZ;

fs/nfs/nfs4client.c

1013

server->acregmax = ctx->acregmax * HZ;

fs/nfs/nfs4client.c

1014

server->acdirmin = ctx->acdirmin * HZ;

fs/nfs/nfs4client.c

1015

server->acdirmax = ctx->acdirmax * HZ;

fs/nfs/nfs4client.c

1016

server->port = ctx->nfs_server.port;

fs/nfs/nfs4client.c

1018

return nfs_init_server_rpcclient(server, &timeparms,

fs/nfs/nfs4client.c

1029

struct nfs_server *server;

fs/nfs/nfs4client.c

1033

server = nfs_alloc_server();

fs/nfs/nfs4client.c

1034

if (!server)

fs/nfs/nfs4client.c

1037

server->cred = get_cred(fc->cred);

fs/nfs/nfs4client.c

1042

error = nfs4_init_server(server, fc);

fs/nfs/nfs4client.c

1046

error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);

fs/nfs/nfs4client.c

1050

return server;

fs/nfs/nfs4client.c

1053

nfs_free_server(server);

fs/nfs/nfs4client.c

1077

struct nfs_server *server;

fs/nfs/nfs4client.c

1081

server = nfs_alloc_server();

fs/nfs/nfs4client.c

1082

if (!server)

fs/nfs/nfs4client.c

1085

server->cred = get_cred(parent_server->cred);

fs/nfs/nfs4client.c

1088

nfs_server_copy_userdata(server, parent_server);

fs/nfs/nfs4client.c

1094

error = nfs4_set_client(server, &cl_init);

fs/nfs/nfs4client.c

1103

error = nfs4_set_client(server, &cl_init);

fs/nfs/nfs4client.c

1110

error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,

fs/nfs/nfs4client.c

1117

error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);

fs/nfs/nfs4client.c

1121

return server;

fs/nfs/nfs4client.c

1124

nfs_free_server(server);

fs/nfs/nfs4client.c

1143

int nfs4_update_server(struct nfs_server *server, const char *hostname,

fs/nfs/nfs4client.c

1146

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4client.c

1147

struct rpc_clnt *clnt = server->client;

fs/nfs/nfs4client.c

1185

nfs_server_remove_lists(server);

fs/nfs/nfs4client.c

1186

set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);

fs/nfs/nfs4client.c

1187

error = nfs4_set_client(server, &cl_init);

fs/nfs/nfs4client.c

1188

clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);

fs/nfs/nfs4client.c

1190

nfs_server_insert_lists(server);

fs/nfs/nfs4client.c

1195

if (server->nfs_client->cl_hostname == NULL) {

fs/nfs/nfs4client.c

1196

server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL);

fs/nfs/nfs4client.c

1197

if (server->nfs_client->cl_hostname == NULL)

fs/nfs/nfs4client.c

1200

nfs_server_insert_lists(server);

fs/nfs/nfs4client.c

1202

return nfs_probe_server(server, NFS_FH(d_inode(server->super->s_root)));

fs/nfs/nfs4client.c

632

static void nfs4_destroy_server(struct nfs_server *server)

fs/nfs/nfs4client.c

636

nfs_server_return_all_delegations(server);

fs/nfs/nfs4client.c

637

unset_pnfs_layoutdriver(server);

fs/nfs/nfs4client.c

638

nfs4_purge_state_owners(server, &freeme);

fs/nfs/nfs4client.c

640

kfree(server->delegation_hash_table);

fs/nfs/nfs4client.c

722

static int nfs4_set_client(struct nfs_server *server,

fs/nfs/nfs4client.c

728

cl_init->cred = server->cred;

fs/nfs/nfs4client.c

744

if (server->flags & NFS_MOUNT_NORESVPORT)

fs/nfs/nfs4client.c

746

if (server->options & NFS_OPTION_MIGRATION)

fs/nfs/nfs4client.c

748

if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status))

fs/nfs/nfs4client.c

750

server->port = rpc_get_port((struct sockaddr *)cl_init->addr);

fs/nfs/nfs4client.c

752

if (server->flags & NFS_MOUNT_NETUNREACH_FATAL)

fs/nfs/nfs4client.c

760

if (server->nfs_client == clp) {

fs/nfs/nfs4client.c

774

server->nfs_client = clp;

fs/nfs/nfs4client.c

775

nfs_sysfs_add_server(server);

fs/nfs/nfs4client.c

776

nfs_sysfs_link_rpc_client(server, clp->cl_rpcclient, "_state");

fs/nfs/nfs4client.c

858

static void nfs4_session_limit_rwsize(struct nfs_server *server)

fs/nfs/nfs4client.c

864

if (!nfs4_has_session(server->nfs_client))

fs/nfs/nfs4client.c

866

sess = server->nfs_client->cl_session;

fs/nfs/nfs4client.c

870

if (server->dtsize > server_resp_sz)

fs/nfs/nfs4client.c

871

server->dtsize = server_resp_sz;

fs/nfs/nfs4client.c

872

if (server->rsize > server_resp_sz)

fs/nfs/nfs4client.c

873

server->rsize = server_resp_sz;

fs/nfs/nfs4client.c

874

if (server->wsize > server_rqst_sz)

fs/nfs/nfs4client.c

875

server->wsize = server_rqst_sz;

fs/nfs/nfs4client.c

881

static void nfs4_session_limit_xasize(struct nfs_server *server)

fs/nfs/nfs4client.c

889

if (!nfs4_has_session(server->nfs_client))

fs/nfs/nfs4client.c

892

sess = server->nfs_client->cl_session;

fs/nfs/nfs4client.c

899

if (server->gxasize > server_gxa_sz)

fs/nfs/nfs4client.c

900

server->gxasize = server_gxa_sz;

fs/nfs/nfs4client.c

901

if (server->sxasize > server_sxa_sz)

fs/nfs/nfs4client.c

902

server->sxasize = server_sxa_sz;

fs/nfs/nfs4client.c

903

if (server->lxasize > server_lxa_sz)

fs/nfs/nfs4client.c

904

server->lxasize = server_lxa_sz;

fs/nfs/nfs4client.c

908

static int nfs4_server_common_setup(struct nfs_server *server,

fs/nfs/nfs4client.c

913

error = nfs4_delegation_hash_alloc(server);

fs/nfs/nfs4client.c

918

if (is_ds_only_client(server->nfs_client))

fs/nfs/nfs4client.c

922

error = nfs4_init_session(server->nfs_client);

fs/nfs/nfs4client.c

926

nfs_server_set_init_caps(server);

fs/nfs/nfs4client.c

929

error = nfs4_get_rootfh(server, mntfh, auth_probe);

fs/nfs/nfs4client.c

934

(unsigned long long) server->fsid.major,

fs/nfs/nfs4client.c

935

(unsigned long long) server->fsid.minor);

fs/nfs/nfs4client.c

938

error = nfs_probe_server(server, mntfh);

fs/nfs/nfs4client.c

942

nfs4_session_limit_rwsize(server);

fs/nfs/nfs4client.c

943

nfs4_session_limit_xasize(server);

fs/nfs/nfs4client.c

945

if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)

fs/nfs/nfs4client.c

946

server->namelen = NFS4_MAXNAMLEN;

fs/nfs/nfs4client.c

948

nfs_server_insert_lists(server);

fs/nfs/nfs4client.c

949

server->mount_time = jiffies;

fs/nfs/nfs4client.c

950

server->destroy = nfs4_destroy_server;

fs/nfs/nfs4client.c

957

static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc)

fs/nfs/nfs4client.c

980

server->flags = ctx->flags;

fs/nfs/nfs4client.c

981

server->options = ctx->options;

fs/nfs/nfs4client.c

982

server->auth_info = ctx->auth_info;

fs/nfs/nfs4client.c

993

error = nfs4_set_client(server, &cl_init);

fs/nfs/nfs4client.c

998

server->bsize = ctx->bsize;

fs/nfs/nfs4client.c

999

server->automount_inherit |= NFS_AUTOMOUNT_INHERIT_BSIZE;

fs/nfs/nfs4file.c

252

struct nfs_server *server = NFS_SERVER(dst_inode);

fs/nfs/nfs4file.c

254

unsigned int bs = server->clone_blksize;

fs/nfs/nfs4file.c

310

struct nfs_server *server;

fs/nfs/nfs4file.c

317

server = NFS_SB(ss_mnt->mnt_sb);

fs/nfs/nfs4file.c

322

status = nfs4_proc_getattr(server, src_fh, fattr, NULL);

fs/nfs/nfs4file.c

362

sp = nfs4_get_state_owner(server, ctx->cred, GFP_KERNEL);

fs/nfs/nfs4getroot.c

13

int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool auth_probe)

fs/nfs/nfs4getroot.c

22

ret = nfs4_proc_get_rootfh(server, mntfh, fattr, auth_probe);

fs/nfs/nfs4getroot.c

35

memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));

fs/nfs/nfs4idmap.c

109

static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr)

fs/nfs/nfs4idmap.c

116

if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) {

fs/nfs/nfs4idmap.c

123

static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr)

fs/nfs/nfs4idmap.c

130

if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) {

fs/nfs/nfs4idmap.c

157

void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr)

fs/nfs/nfs4idmap.c

159

if (nfs_fattr_map_owner_name(server, fattr))

fs/nfs/nfs4idmap.c

161

if (nfs_fattr_map_group_name(server, fattr))

fs/nfs/nfs4idmap.c

732

int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid)

fs/nfs/nfs4idmap.c

734

struct idmap *idmap = server->nfs_client->cl_idmap;

fs/nfs/nfs4idmap.c

749

int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, kgid_t *gid)

fs/nfs/nfs4idmap.c

751

struct idmap *idmap = server->nfs_client->cl_idmap;

fs/nfs/nfs4idmap.c

766

int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf, size_t buflen)

fs/nfs/nfs4idmap.c

768

struct idmap *idmap = server->nfs_client->cl_idmap;

fs/nfs/nfs4idmap.c

773

if (!(server->caps & NFS_CAP_UIDGID_NOMAP))

fs/nfs/nfs4idmap.c

780

int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen)

fs/nfs/nfs4idmap.c

782

struct idmap *idmap = server->nfs_client->cl_idmap;

fs/nfs/nfs4idmap.c

787

if (!(server->caps & NFS_CAP_UIDGID_NOMAP))

fs/nfs/nfs4namespace.c

205

struct nfs_server *server,

fs/nfs/nfs4namespace.c

223

nfs_auth_info_match(&server->auth_info, pflavor)) {

fs/nfs/nfs4namespace.c

451

int nfs4_submount(struct fs_context *fc, struct nfs_server *server)

fs/nfs/nfs4namespace.c

483

static int nfs4_try_replacing_one_location(struct nfs_server *server,

fs/nfs/nfs4namespace.c

487

struct net *net = rpc_net_ns(server->client);

fs/nfs/nfs4namespace.c

519

error = nfs4_update_server(server, hostname, sap, salen, net);

fs/nfs/nfs4namespace.c

541

int nfs4_replace_transport(struct nfs_server *server,

fs/nfs/nfs4namespace.c

567

error = nfs4_try_replacing_one_location(server, page,

fs/nfs/nfs4proc.c

10051

static int _nfs41_proc_secinfo_no_name(struct nfs_server *server,

fs/nfs/nfs4proc.c

10056

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

10069

.seq_server = server,

fs/nfs/nfs4proc.c

10074

.rpc_client = server->client,

fs/nfs/nfs4proc.c

10099

static int nfs41_proc_secinfo_no_name(struct nfs_server *server,

fs/nfs/nfs4proc.c

10112

if (_nfs4_is_integrity_protected(server->nfs_client))

fs/nfs/nfs4proc.c

10113

err = _nfs41_proc_secinfo_no_name(server, fhandle,

fs/nfs/nfs4proc.c

10123

err = _nfs41_proc_secinfo_no_name(server, fhandle,

fs/nfs/nfs4proc.c

10132

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

10139

static int nfs41_find_root_sec(struct nfs_server *server,

fs/nfs/nfs4proc.c

10156

err = nfs41_proc_secinfo_no_name(server, fhandle, flavors);

fs/nfs/nfs4proc.c

10163

err = nfs4_find_root_sec(server, fhandle, fattr);

fs/nfs/nfs4proc.c

10184

if (!nfs_auth_info_match(&server->auth_info, flavor))

fs/nfs/nfs4proc.c

10188

err = nfs4_lookup_root_sec(server, fhandle, fattr,

fs/nfs/nfs4proc.c

10206

static int _nfs41_test_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

10221

struct rpc_clnt *rpc_client = server->client;

fs/nfs/nfs4proc.c

10222

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

10228

status = nfs4_call_sync_sequence(rpc_client, server, &msg,

fs/nfs/nfs4proc.c

10238

static void nfs4_handle_delay_or_session_error(struct nfs_server *server,

fs/nfs/nfs4proc.c

10245

nfs4_handle_exception(server, err, exception);

fs/nfs/nfs4proc.c

10252

nfs4_do_handle_exception(server, err, exception);

fs/nfs/nfs4proc.c

10267

static int nfs41_test_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

10276

err = _nfs41_test_stateid(server, stateid, cred);

fs/nfs/nfs4proc.c

10277

nfs4_handle_delay_or_session_error(server, err, &exception);

fs/nfs/nfs4proc.c

10283

struct nfs_server *server;

fs/nfs/nfs4proc.c

10291

nfs4_setup_sequence(data->server->nfs_client,

fs/nfs/nfs4proc.c

10305

if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)

fs/nfs/nfs4proc.c

10313

struct nfs_client *clp = data->server->nfs_client;

fs/nfs/nfs4proc.c

10335

static int nfs41_free_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

10345

.rpc_client = server->client,

fs/nfs/nfs4proc.c

10352

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

10364

data->server = server;

fs/nfs/nfs4proc.c

10382

nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)

fs/nfs/nfs4proc.c

10386

nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);

fs/nfs/nfs4proc.c

10387

nfs4_free_lock_state(server, lsp);

fs/nfs/nfs4proc.c

10614

struct nfs_server *server;

fs/nfs/nfs4proc.c

10617

server = nfs_clone_server(source, fh, fattr, flavor);

fs/nfs/nfs4proc.c

10618

if (IS_ERR(server))

fs/nfs/nfs4proc.c

10619

return server;

fs/nfs/nfs4proc.c

10621

error = nfs4_delegation_hash_alloc(server);

fs/nfs/nfs4proc.c

10623

nfs_free_server(server);

fs/nfs/nfs4proc.c

10627

return server;

fs/nfs/nfs4proc.c

1133

struct nfs_server *server,

fs/nfs/nfs4proc.c

1139

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

1141

.seq_server = server,

fs/nfs/nfs4proc.c

1157

struct nfs_server *server,

fs/nfs/nfs4proc.c

1164

if (server->caps & NFS_CAP_MOVEABLE)

fs/nfs/nfs4proc.c

1166

return nfs4_do_call_sync(clnt, server, msg, args, res, task_flags);

fs/nfs/nfs4proc.c

1171

struct nfs_server *server,

fs/nfs/nfs4proc.c

1177

nfs4_init_sequence(server->nfs_client, args, res, cache_reply, 0);

fs/nfs/nfs4proc.c

1178

return nfs4_call_sync_sequence(clnt, server, msg, args, res);

fs/nfs/nfs4proc.c

1267

static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,

fs/nfs/nfs4proc.c

1272

if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))

fs/nfs/nfs4proc.c

1274

server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;

fs/nfs/nfs4proc.c

1310

nfs4_map_atomic_open_share(struct nfs_server *server,

fs/nfs/nfs4proc.c

1315

if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))

fs/nfs/nfs4proc.c

1323

if (server->caps & NFS_CAP_DELEGTIME)

fs/nfs/nfs4proc.c

1325

if (server->caps & NFS_CAP_OPEN_XOR)

fs/nfs/nfs4proc.c

1332

nfs4_map_atomic_open_claim(struct nfs_server *server,

fs/nfs/nfs4proc.c

1335

if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)

fs/nfs/nfs4proc.c

1354

p->o_res.server = p->o_arg.server;

fs/nfs/nfs4proc.c

1368

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

1377

p->f_attr.label = nfs4_label_alloc(server, gfp_mask);

fs/nfs/nfs4proc.c

1381

p->a_label = nfs4_label_alloc(server, gfp_mask);

fs/nfs/nfs4proc.c

1385

alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;

fs/nfs/nfs4proc.c

1396

p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);

fs/nfs/nfs4proc.c

1397

p->o_arg.share_access = nfs4_map_atomic_open_share(server,

fs/nfs/nfs4proc.c

1420

nfs_access_xattr_mask(server);

fs/nfs/nfs4proc.c

1422

p->o_arg.clientid = server->nfs_client->cl_clientid;

fs/nfs/nfs4proc.c

1426

p->o_arg.server = server;

fs/nfs/nfs4proc.c

1427

p->o_arg.bitmask = nfs4_bitmask(server, label);

fs/nfs/nfs4proc.c

152

static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)

fs/nfs/nfs4proc.c

155

return server->attr_bitmask;

fs/nfs/nfs4proc.c

157

return server->attr_bitmask_nl;

fs/nfs/nfs4proc.c

168

nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)

fs/nfs/nfs4proc.c

169

{ return server->attr_bitmask; }

fs/nfs/nfs4proc.c

1830

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

1831

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

1875

nfs4_test_and_free_stateid(server, &freeme,

fs/nfs/nfs4proc.c

2170

struct nfs_server *server = NFS_SB(opendata->dentry->d_sb);

fs/nfs/nfs4proc.c

2178

nfs4_map_atomic_open_share(server, fmode, openflags);

fs/nfs/nfs4proc.c

2263

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2269

if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))

fs/nfs/nfs4proc.c

2273

nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

2293

static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, struct file_lock *fl, int err)

fs/nfs/nfs4proc.c

2315

nfs4_schedule_lease_recovery(server->nfs_client);

fs/nfs/nfs4proc.c

2318

nfs4_schedule_migration_recovery(server);

fs/nfs/nfs4proc.c

2321

nfs4_schedule_lease_moved_recovery(server->nfs_client);

fs/nfs/nfs4proc.c

2330

nfs4_schedule_stateid_recovery(server, state);

fs/nfs/nfs4proc.c

2351

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2378

return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);

fs/nfs/nfs4proc.c

2385

nfs4_setup_sequence(data->o_arg.server->nfs_client,

fs/nfs/nfs4proc.c

2399

renew_lease(data->o_res.server, data->timestamp);

fs/nfs/nfs4proc.c

2433

struct nfs_server *server = NFS_SERVER(d_inode(data->dir));

fs/nfs/nfs4proc.c

2442

.rpc_client = server->client,

fs/nfs/nfs4proc.c

2451

nfs4_init_sequence(server->nfs_client, &data->c_arg.seq_args,

fs/nfs/nfs4proc.c

2507

if (nfs4_setup_sequence(data->o_arg.server->nfs_client,

fs/nfs/nfs4proc.c

2558

renew_lease(data->o_res.server, data->timestamp);

fs/nfs/nfs4proc.c

2598

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

2599

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

2610

.rpc_client = server->client,

fs/nfs/nfs4proc.c

2714

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

2729

nfs_fattr_map_and_free_names(server, &data->f_attr);

fs/nfs/nfs4proc.c

2743

server->caps &= ~NFS_CAP_POSIX_LOCK;

fs/nfs/nfs4proc.c

2755

nfs4_proc_getattr(server, fh, o_res->f_attr, NULL);

fs/nfs/nfs4proc.c

2788

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2795

if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))

fs/nfs/nfs4proc.c

2802

nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

2830

static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

2846

status = nfs41_test_stateid(server, stateid, cred);

fs/nfs/nfs4proc.c

2857

nfs41_free_stateid(server, stateid, cred, true);

fs/nfs/nfs4proc.c

2863

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2892

status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);

fs/nfs/nfs4proc.c

2928

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2944

status = nfs41_test_and_free_expired_stateid(server,

fs/nfs/nfs4proc.c

2978

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

2985

status = nfs41_test_and_free_expired_stateid(server, stateid, cred);

fs/nfs/nfs4proc.c

3023

const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask;

fs/nfs/nfs4proc.c

3060

struct nfs_server *server = sp->so_server;

fs/nfs/nfs4proc.c

3079

if (server->caps & NFS_CAP_POSIX_LOCK)

fs/nfs/nfs4proc.c

3144

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

3157

sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);

fs/nfs/nfs4proc.c

3162

status = nfs4_client_recover_expired_lease(server->nfs_client);

fs/nfs/nfs4proc.c

3175

if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {

fs/nfs/nfs4proc.c

3217

if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {

fs/nfs/nfs4proc.c

3241

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

3291

nfs4_schedule_lease_recovery(server->nfs_client);

fs/nfs/nfs4proc.c

3300

if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))

fs/nfs/nfs4proc.c

3302

res = ERR_PTR(nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

3314

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

3358

status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);

fs/nfs/nfs4proc.c

3362

renew_lease(server, timestamp);

fs/nfs/nfs4proc.c

3371

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

3377

.server = server,

fs/nfs/nfs4proc.c

3383

.server = server,

fs/nfs/nfs4proc.c

3404

nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label),

fs/nfs/nfs4proc.c

3415

server->nfs_client->cl_hostname);

fs/nfs/nfs4proc.c

3424

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

3572

struct nfs_server *server = NFS_SERVER(calldata->inode);

fs/nfs/nfs4proc.c

3596

renew_lease(server, calldata->timestamp);

fs/nfs/nfs4proc.c

3615

nfs4_free_revoked_stateid(server,

fs/nfs/nfs4proc.c

3625

server, task->tk_status, &exception);

fs/nfs/nfs4proc.c

3649

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

3706

server->cache_consistency_bitmask,

fs/nfs/nfs4proc.c

3752

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

3753

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

3763

.rpc_client = server->client,

fs/nfs/nfs4proc.c

3797

calldata->res.server = server;

fs/nfs/nfs4proc.c

3874

static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)

fs/nfs/nfs4proc.c

3876

u32 minorversion = server->nfs_client->cl_minorversion;

fs/nfs/nfs4proc.c

3905

status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

3932

memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));

fs/nfs/nfs4proc.c

3933

server->caps &=

fs/nfs/nfs4proc.c

3937

server->fattr_valid = NFS_ATTR_FATTR_V4;

fs/nfs/nfs4proc.c

3940

server->caps |= NFS_CAP_ACLS;

fs/nfs/nfs4proc.c

3942

server->caps |= NFS_CAP_HARDLINKS;

fs/nfs/nfs4proc.c

3944

server->caps |= NFS_CAP_SYMLINKS;

fs/nfs/nfs4proc.c

3946

server->caps |= NFS_CAP_CASE_INSENSITIVE;

fs/nfs/nfs4proc.c

3948

server->caps |= NFS_CAP_CASE_PRESERVING;

fs/nfs/nfs4proc.c

3951

server->caps |= NFS_CAP_SECURITY_LABEL;

fs/nfs/nfs4proc.c

3954

server->caps |= NFS_CAP_FS_LOCATIONS;

fs/nfs/nfs4proc.c

3956

server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID;

fs/nfs/nfs4proc.c

3958

server->fattr_valid &= ~NFS_ATTR_FATTR_MODE;

fs/nfs/nfs4proc.c

3960

server->fattr_valid &= ~NFS_ATTR_FATTR_NLINK;

fs/nfs/nfs4proc.c

3962

server->fattr_valid &= ~(NFS_ATTR_FATTR_OWNER |

fs/nfs/nfs4proc.c

3965

server->fattr_valid &= ~(NFS_ATTR_FATTR_GROUP |

fs/nfs/nfs4proc.c

3968

server->fattr_valid &= ~NFS_ATTR_FATTR_SPACE_USED;

fs/nfs/nfs4proc.c

3970

server->fattr_valid &= ~NFS_ATTR_FATTR_ATIME;

fs/nfs/nfs4proc.c

3972

server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME;

fs/nfs/nfs4proc.c

3974

server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME;

fs/nfs/nfs4proc.c

3976

server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME;

fs/nfs/nfs4proc.c

3978

server->fattr_valid &= ~NFS_ATTR_FATTR_BTIME;

fs/nfs/nfs4proc.c

3979

memcpy(server->attr_bitmask_nl, res.attr_bitmask,

fs/nfs/nfs4proc.c

3980

sizeof(server->attr_bitmask));

fs/nfs/nfs4proc.c

3981

server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;

fs/nfs/nfs4proc.c

3985

server->caps |= NFS_CAP_OPEN_XOR;

fs/nfs/nfs4proc.c

3987

server->caps |= NFS_CAP_DELEGTIME;

fs/nfs/nfs4proc.c

3989

memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));

fs/nfs/nfs4proc.c

3990

server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;

fs/nfs/nfs4proc.c

3991

server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;

fs/nfs/nfs4proc.c

3992

server->cache_consistency_bitmask[2] = 0;

fs/nfs/nfs4proc.c

3997

memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,

fs/nfs/nfs4proc.c

3998

sizeof(server->exclcreat_bitmask));

fs/nfs/nfs4proc.c

4000

server->acl_bitmask = res.acl_bitmask;

fs/nfs/nfs4proc.c

4001

server->fh_expire_type = res.fh_expire_type;

fs/nfs/nfs4proc.c

4007

int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)

fs/nfs/nfs4proc.c

4015

err = nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

4016

_nfs4_server_capabilities(server, fhandle),

fs/nfs/nfs4proc.c

4024

struct nfs_server *server)

fs/nfs/nfs4proc.c

4050

clp->cl_net, server->port);

fs/nfs/nfs4proc.c

4089

static int _nfs4_discover_trunking(struct nfs_server *server,

fs/nfs/nfs4proc.c

4095

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

410

static void nfs4_test_and_free_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

4117

status = nfs4_proc_get_locations(server, fhandle, locations, page,

fs/nfs/nfs4proc.c

4127

server);

fs/nfs/nfs4proc.c

414

const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;

fs/nfs/nfs4proc.c

4140

static int nfs4_discover_trunking(struct nfs_server *server,

fs/nfs/nfs4proc.c

4146

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

4152

err = nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

4153

_nfs4_discover_trunking(server, fhandle),

fs/nfs/nfs4proc.c

416

ops->test_and_free_expired(server, stateid, cred);

fs/nfs/nfs4proc.c

4160

static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

4171

.server = server,

fs/nfs/nfs4proc.c

4182

return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

4185

static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

419

static void __nfs4_free_revoked_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

4193

err = _nfs4_lookup_root(server, fhandle, fattr);

fs/nfs/nfs4proc.c

4194

trace_nfs4_lookup_root(server, fhandle, fattr, err);

fs/nfs/nfs4proc.c

4200

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

4207

static int nfs4_lookup_root_sec(struct nfs_server *server,

fs/nfs/nfs4proc.c

4216

auth = rpcauth_create(&auth_args, server->client);

fs/nfs/nfs4proc.c

4219

return nfs4_lookup_root(server, fhandle, fattr);

fs/nfs/nfs4proc.c

4231

int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

424

nfs4_test_and_free_stateid(server, stateid, cred);

fs/nfs/nfs4proc.c

4245

if (server->auth_info.flavor_len > 0) {

fs/nfs/nfs4proc.c

4247

for (i = 0; i < server->auth_info.flavor_len; i++) {

fs/nfs/nfs4proc.c

4249

server, fhandle, fattr,

fs/nfs/nfs4proc.c

4250

server->auth_info.flavors[i]);

fs/nfs/nfs4proc.c

4258

status = nfs4_lookup_root_sec(server, fhandle, fattr,

fs/nfs/nfs4proc.c

427

static void nfs4_free_revoked_stateid(struct nfs_server *server,

fs/nfs/nfs4proc.c

4287

int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

4293

status = nfs4_lookup_root(server, fhandle, fattr);

fs/nfs/nfs4proc.c

4296

status = server->nfs_client->cl_mvops->find_root_sec(

fs/nfs/nfs4proc.c

4297

server, fhandle, fattr);

fs/nfs/nfs4proc.c

4302

static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,

fs/nfs/nfs4proc.c

4308

error = nfs4_server_capabilities(server, mntfh);

fs/nfs/nfs4proc.c

4314

error = nfs4_proc_getattr(server, mntfh, fattr, NULL);

fs/nfs/nfs4proc.c

4321

!nfs_fsid_equal(&server->fsid, &fattr->fsid))

fs/nfs/nfs4proc.c

4322

memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));

fs/nfs/nfs4proc.c

434

__nfs4_free_revoked_stateid(server, &tmp, cred);

fs/nfs/nfs4proc.c

4411

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

4421

.server = server,

fs/nfs/nfs4proc.c

4429

.seq_server = server,

fs/nfs/nfs4proc.c

4434

.rpc_client = server->client,

fs/nfs/nfs4proc.c

4439

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

4447

if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))

fs/nfs/nfs4proc.c

4454

nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), inode, 0);

fs/nfs/nfs4proc.c

4471

server->caps &= ~NFS_CAP_DIR_DELEG;

fs/nfs/nfs4proc.c

4479

int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

4487

err = _nfs4_proc_getattr(server, fhandle, fattr, inode);

fs/nfs/nfs4proc.c

4488

trace_nfs4_getattr(server, fhandle, fattr, err);

fs/nfs/nfs4proc.c

4491

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

4566

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

4569

.bitmask = server->attr_bitmask,

fs/nfs/nfs4proc.c

4574

.server = server,

fs/nfs/nfs4proc.c

4592

args.bitmask = nfs4_bitmask(server, fattr->label);

fs/nfs/nfs4proc.c

4597

nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);

fs/nfs/nfs4proc.c

4598

status = nfs4_do_call_sync(clnt, server, &msg,

fs/nfs/nfs4proc.c

4689

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

4692

.bitmask = server->attr_bitmask,

fs/nfs/nfs4proc.c

4696

.server = server,

fs/nfs/nfs4proc.c

4707

if (server->flags & NFS_MOUNT_SOFTREVAL)

fs/nfs/nfs4proc.c

4709

if (server->caps & NFS_CAP_MOVEABLE)

fs/nfs/nfs4proc.c

4712

args.bitmask = nfs4_bitmask(server, fattr->label);

fs/nfs/nfs4proc.c

4715

nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);

fs/nfs/nfs4proc.c

4718

status = nfs4_do_call_sync(clnt, server, &msg, &args.seq_args,

fs/nfs/nfs4proc.c

4743

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

4749

.server = server,

fs/nfs/nfs4proc.c

4764

args.bitmask = server->cache_consistency_bitmask;

fs/nfs/nfs4proc.c

4766

status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

4856

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

4870

if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))

fs/nfs/nfs4proc.c

4886

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

4892

.server = server,

fs/nfs/nfs4proc.c

4902

status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);

fs/nfs/nfs4proc.c

4960

struct nfs_server *server = NFS_SB(dentry->d_sb);

fs/nfs/nfs4proc.c

4962

res->server = server;

fs/nfs/nfs4proc.c

4964

nfs4_init_sequence(server->nfs_client, &args->seq_args,

fs/nfs/nfs4proc.c

4991

if (nfs4_async_handle_error(task, res->server, NULL,

fs/nfs/nfs4proc.c

5006

struct nfs_server *server = NFS_SB(old_dentry->d_sb);

fs/nfs/nfs4proc.c

5019

res->server = server;

fs/nfs/nfs4proc.c

5020

nfs4_init_sequence(server->nfs_client, &arg->seq_args,

fs/nfs/nfs4proc.c

503

static int nfs4_do_handle_exception(struct nfs_server *server,

fs/nfs/nfs4proc.c

5040

if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)

fs/nfs/nfs4proc.c

506

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

5065

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

5074

.server = server,

fs/nfs/nfs4proc.c

5083

res.fattr = nfs_alloc_fattr_with_label(server);

fs/nfs/nfs4proc.c

5088

nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label),

fs/nfs/nfs4proc.c

5091

status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);

fs/nfs/nfs4proc.c

5135

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

5137

data->fattr.label = nfs4_label_alloc(server, GFP_KERNEL);

fs/nfs/nfs4proc.c

5145

data->arg.server = server;

fs/nfs/nfs4proc.c

5149

data->arg.bitmask = nfs4_bitmask(server, data->fattr.label);

fs/nfs/nfs4proc.c

5151

data->res.server = server;

fs/nfs/nfs4proc.c

5281

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

5291

if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))

fs/nfs/nfs4proc.c

5310

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

5329

if (!(server->caps & NFS_CAP_SECURITY_LABEL))

fs/nfs/nfs4proc.c

5330

args.bitmask = server->attr_bitmask_nl;

fs/nfs/nfs4proc.c

5332

args.bitmask = server->attr_bitmask;

fs/nfs/nfs4proc.c

5336

status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,

fs/nfs/nfs4proc.c

5403

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

5412

if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))

fs/nfs/nfs4proc.c

5426

static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

5431

.bitmask = server->attr_bitmask,

fs/nfs/nfs4proc.c

5443

return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

5446

static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)

fs/nfs/nfs4proc.c

5453

err = nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

5454

_nfs4_proc_statfs(server, fhandle, fsstat),

fs/nfs/nfs4proc.c

5460

static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

5465

.bitmask = server->attr_bitmask,

fs/nfs/nfs4proc.c

5476

return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

5479

static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)

fs/nfs/nfs4proc.c

5487

err = _nfs4_do_fsinfo(server, fhandle, fsinfo);

fs/nfs/nfs4proc.c

5488

trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);

fs/nfs/nfs4proc.c

5490

nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time);

fs/nfs/nfs4proc.c

5493

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

5498

static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)

fs/nfs/nfs4proc.c

5503

error = nfs4_do_fsinfo(server, fhandle, fsinfo);

fs/nfs/nfs4proc.c

5506

server->pnfs_blksize = fsinfo->blksize;

fs/nfs/nfs4proc.c

5507

set_pnfs_layoutdriver(server, fhandle, fsinfo);

fs/nfs/nfs4proc.c

5513

static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

5518

.bitmask = server->attr_bitmask,

fs/nfs/nfs4proc.c

5536

return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

5539

static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

554

ret = nfs4_schedule_stateid_recovery(server, state);

fs/nfs/nfs4proc.c

5548

err = nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

5549

_nfs4_proc_pathconf(server, fhandle, pathconf),

fs/nfs/nfs4proc.c

5594

struct nfs_server *server = NFS_SERVER(hdr->inode);

fs/nfs/nfs4proc.c

5605

server, task->tk_status, &exception);

fs/nfs/nfs4proc.c

5614

renew_lease(server, hdr->timestamp);

fs/nfs/nfs4proc.c

563

ret = nfs4_schedule_migration_recovery(server);

fs/nfs/nfs4proc.c

5635

struct nfs_server *server = NFS_SERVER(hdr->inode);

fs/nfs/nfs4proc.c

5640

server->caps &= ~NFS_CAP_READ_PLUS;

fs/nfs/nfs4proc.c

5778

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

5807

bitmask[i] &= server->attr_bitmask[i];

fs/nfs/nfs4proc.c

5814

struct nfs_server *server = NFS_SERVER(hdr->inode);

fs/nfs/nfs4proc.c

5821

server->cache_consistency_bitmask,

fs/nfs/nfs4proc.c

5828

hdr->res.server = server;

fs/nfs/nfs4proc.c

5832

nfs4_init_sequence(server->nfs_client, &hdr->args.seq_args,

fs/nfs/nfs4proc.c

5834

nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr);

fs/nfs/nfs4proc.c

5868

struct nfs_server *server = NFS_SERVER(data->inode);

fs/nfs/nfs4proc.c

5872

data->res.server = server;

fs/nfs/nfs4proc.c

5874

nfs4_init_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs4proc.c

5876

nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client,

fs/nfs/nfs4proc.c

5884

struct nfs_server *server = NFS_SERVER(dst_inode);

fs/nfs/nfs4proc.c

589

nfs_inc_server_stats(server, NFSIOS_DELAY);

fs/nfs/nfs4proc.c

5892

return nfs4_call_sync(server->client, server, &msg,

fs/nfs/nfs4proc.c

5914

static bool nfs4_server_supports_acls(const struct nfs_server *server,

fs/nfs/nfs4proc.c

5919

return server->attr_bitmask[0] & FATTR4_WORD0_ACL;

fs/nfs/nfs4proc.c

5921

return server->attr_bitmask[1] & FATTR4_WORD1_DACL;

fs/nfs/nfs4proc.c

5923

return server->attr_bitmask[1] & FATTR4_WORD1_SACL;

fs/nfs/nfs4proc.c

605

if (server->caps & NFS_CAP_UIDGID_NOMAP) {

fs/nfs/nfs4proc.c

606

server->caps &= ~NFS_CAP_UIDGID_NOMAP;

fs/nfs/nfs4proc.c

6067

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6070

buflen = server->rsize;

fs/nfs/nfs4proc.c

612

server->nfs_client->cl_hostname);

fs/nfs/nfs4proc.c

6147

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6152

if (!nfs4_server_supports_acls(server, type))

fs/nfs/nfs4proc.c

6170

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6190

if (!nfs4_server_supports_acls(server, type))

fs/nfs/nfs4proc.c

6198

ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);

fs/nfs/nfs4proc.c

6250

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6263

.server = server,

fs/nfs/nfs4proc.c

627

static int nfs4_exception_should_retrans(const struct nfs_server *server,

fs/nfs/nfs4proc.c

6274

ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

630

if (server->flags & NFS_MOUNT_SOFTERR && nfs_delay_retrans >= 0) {

fs/nfs/nfs4proc.c

6308

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6313

.server = server,

fs/nfs/nfs4proc.c

6319

.server = server,

fs/nfs/nfs4proc.c

6330

status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);

fs/nfs/nfs4proc.c

640

int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)

fs/nfs/nfs4proc.c

642

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

645

ret = nfs4_do_handle_exception(server, errorcode, exception);

fs/nfs/nfs4proc.c

647

int ret2 = nfs4_exception_should_retrans(server, exception);

fs/nfs/nfs4proc.c

660

if (test_bit(NFS_MIG_FAILED, &server->mig_status))

fs/nfs/nfs4proc.c

6710

renew_lease(data->res.server, data->timestamp);

fs/nfs/nfs4proc.c

6715

nfs4_free_revoked_stateid(data->res.server,

fs/nfs/nfs4proc.c

672

nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,

fs/nfs/nfs4proc.c

6741

data->res.server, task->tk_status,

fs/nfs/nfs4proc.c

675

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

6790

nfs4_setup_sequence(d_data->res.server->nfs_client,

fs/nfs/nfs4proc.c

6808

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6815

.rpc_client = server->client,

fs/nfs/nfs4proc.c

6829

nfs4_state_protect(server->nfs_client,

fs/nfs/nfs4proc.c

6836

server->cache_consistency_bitmask, inode, 0);

fs/nfs/nfs4proc.c

6841

data->res.server = server;

fs/nfs/nfs4proc.c

687

ret = nfs4_do_handle_exception(server, errorcode, exception);

fs/nfs/nfs4proc.c

6871

nfs4_init_sequence(server->nfs_client, &data->args.seq_args,

fs/nfs/nfs4proc.c

689

int ret2 = nfs4_exception_should_retrans(server, exception);

fs/nfs/nfs4proc.c

6895

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6908

err = nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

6916

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

6917

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

6940

arg.lock_owner.s_dev = server->s_dev;

fs/nfs/nfs4proc.c

6941

status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);

fs/nfs/nfs4proc.c

7014

struct nfs_server *server;

fs/nfs/nfs4proc.c

7048

p->server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

705

if (test_bit(NFS_MIG_FAILED, &server->mig_status))

fs/nfs/nfs4proc.c

7078

renew_lease(calldata->server, calldata->timestamp);

fs/nfs/nfs4proc.c

7086

nfs4_free_revoked_stateid(calldata->server,

fs/nfs/nfs4proc.c

7103

calldata->server, task->tk_status,

fs/nfs/nfs4proc.c

7127

if (nfs4_setup_sequence(calldata->server->nfs_client,

fs/nfs/nfs4proc.c

722

nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,

fs/nfs/nfs4proc.c

7251

struct nfs_server *server;

fs/nfs/nfs4proc.c

7260

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

7272

alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;

fs/nfs/nfs4proc.c

7276

p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;

fs/nfs/nfs4proc.c

7278

p->arg.lock_owner.s_dev = server->s_dev;

fs/nfs/nfs4proc.c

7281

p->server = server;

fs/nfs/nfs4proc.c

7320

if (nfs4_setup_sequence(data->server->nfs_client,

fs/nfs/nfs4proc.c

733

task->tk_status = nfs4_async_handle_exception(task, server,

fs/nfs/nfs4proc.c

7412

static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)

fs/nfs/nfs4proc.c

7421

nfs4_schedule_stateid_recovery(server, lsp->ls_state);

fs/nfs/nfs4proc.c

7425

nfs4_schedule_lease_recovery(server->nfs_client);

fs/nfs/nfs4proc.c

7474

nfs4_handle_setlk_error(data->server, data->lsp,

fs/nfs/nfs4proc.c

7486

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

7499

nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

7506

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

7528

nfs4_handle_exception(server, err, &exception);

fs/nfs/nfs4proc.c

761

void renew_lease(const struct nfs_server *server, unsigned long timestamp)

fs/nfs/nfs4proc.c

763

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

7657

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

7658

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

7664

.s_dev = server->s_dev },

fs/nfs/nfs4proc.c

7784

struct nfs_server *server = NFS_SERVER(state->inode);

fs/nfs/nfs4proc.c

7796

return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err);

fs/nfs/nfs4proc.c

8049

struct nfs_server *server = NFS_SERVER(dir);

fs/nfs/nfs4proc.c

8080

fs_locations->server = server;

fs/nfs/nfs4proc.c

8082

status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

8116

static int _nfs41_proc_get_locations(struct nfs_server *server,

fs/nfs/nfs4proc.c

8121

struct rpc_clnt *clnt = server->client;

fs/nfs/nfs4proc.c

8122

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

8143

.seq_server = server,

fs/nfs/nfs4proc.c

8157

locations->server = server;

fs/nfs/nfs4proc.c

8186

int nfs4_proc_get_locations(struct nfs_server *server,

fs/nfs/nfs4proc.c

8191

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

8200

(unsigned long long)server->fsid.major,

fs/nfs/nfs4proc.c

8201

(unsigned long long)server->fsid.minor,

fs/nfs/nfs4proc.c

8206

status = ops->get_locations(server, fhandle, locations, page,

fs/nfs/nfs4proc.c

8210

nfs4_handle_exception(server, status, &exception);

fs/nfs/nfs4proc.c

8224

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

8225

struct rpc_clnt *clnt = server->client;

fs/nfs/nfs4proc.c

8243

nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 1);

fs/nfs/nfs4proc.c

8244

status = nfs4_call_sync_sequence(clnt, server, &msg,

fs/nfs/nfs4proc.c

8269

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

8270

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4proc.c

8279

(unsigned long long)server->fsid.major,

fs/nfs/nfs4proc.c

8280

(unsigned long long)server->fsid.minor,

fs/nfs/nfs4proc.c

8288

nfs4_handle_exception(server, status, &exception);

fs/nfs/nfs4proc.c

9566

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

fs/nfs/nfs4proc.c

9568

nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args,

fs/nfs/nfs4proc.c

9584

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

9661

err = nfs4_handle_exception(server, nfs4err, exception);

fs/nfs/nfs4proc.c

9672

size_t max_response_pages(struct nfs_server *server)

fs/nfs/nfs4proc.c

9674

u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;

fs/nfs/nfs4proc.c

9697

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/nfs4proc.c

97

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/nfs4proc.c

9706

.rpc_client = server->client,

fs/nfs/nfs4proc.c

9716

nfs4_init_sequence(server->nfs_client, &lgp->args.seq_args,

fs/nfs/nfs4proc.c

9767

struct nfs_server *server;

fs/nfs/nfs4proc.c

9786

server = NFS_SERVER(lrp->args.inode);

fs/nfs/nfs4proc.c

9803

nfs4_schedule_session_recovery(server->nfs_client->cl_session,

fs/nfs/nfs4proc.c

9810

if (nfs4_async_handle_error(task, server, NULL, NULL) ==

fs/nfs/nfs4proc.c

9897

_nfs4_proc_getdeviceinfo(struct nfs_server *server,

fs/nfs/nfs4proc.c

9917

status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);

fs/nfs/nfs4proc.c

9923

trace_nfs4_getdeviceinfo(server, &pdev->dev_id, status);

fs/nfs/nfs4proc.c

9930

int nfs4_proc_getdeviceinfo(struct nfs_server *server,

fs/nfs/nfs4proc.c

9938

err = nfs4_handle_exception(server,

fs/nfs/nfs4proc.c

9939

_nfs4_proc_getdeviceinfo(server, pdev, cred),

fs/nfs/nfs4proc.c

9949

struct nfs_server *server = NFS_SERVER(data->args.inode);

fs/nfs/nfs4proc.c

9951

nfs4_setup_sequence(server->nfs_client,

fs/nfs/nfs4proc.c

9961

struct nfs_server *server = NFS_SERVER(data->args.inode);

fs/nfs/nfs4proc.c

9976

if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {

fs/nfs/nfs4state.c

1213

int nfs4_schedule_migration_recovery(const struct nfs_server *server)

fs/nfs/nfs4state.c

1215

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

1217

if (server->fh_expire_type != NFS4_FH_PERSISTENT) {

fs/nfs/nfs4state.c

1223

if (test_bit(NFS_MIG_FAILED, &server->mig_status))

fs/nfs/nfs4state.c

1228

(unsigned long long)server->fsid.major,

fs/nfs/nfs4state.c

1229

(unsigned long long)server->fsid.minor,

fs/nfs/nfs4state.c

1233

&((struct nfs_server *)server)->mig_status);

fs/nfs/nfs4state.c

1321

int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)

fs/nfs/nfs4state.c

1323

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

160

nfs4_get_renew_cred_server_locked(struct nfs_server *server)

fs/nfs/nfs4state.c

166

for (pos = rb_first(&server->state_owners);

fs/nfs/nfs4state.c

1682

static void nfs4_reset_seqids(struct nfs_server *server,

fs/nfs/nfs4state.c

1685

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

1691

for (pos = rb_first(&server->state_owners);

fs/nfs/nfs4state.c

1709

struct nfs_server *server;

fs/nfs/nfs4state.c

1712

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/nfs4state.c

1713

nfs4_reset_seqids(server, mark_reclaim);

fs/nfs/nfs4state.c

1735

static void nfs4_clear_reclaim_server(struct nfs_server *server)

fs/nfs/nfs4state.c

1737

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

1743

for (pos = rb_first(&server->state_owners);

fs/nfs/nfs4state.c

1761

struct nfs_server *server;

fs/nfs/nfs4state.c

1767

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)

fs/nfs/nfs4state.c

1768

nfs4_clear_reclaim_server(server);

fs/nfs/nfs4state.c

1844

struct nfs_server *server;

fs/nfs/nfs4state.c

1855

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/nfs4state.c

1856

nfs4_purge_state_owners(server, &freeme);

fs/nfs/nfs4state.c

1858

for (pos = rb_first(&server->state_owners);

fs/nfs/nfs4state.c

188

struct nfs_server *server;

fs/nfs/nfs4state.c

197

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/nfs4state.c

198

cred = nfs4_get_renew_cred_server_locked(server);

fs/nfs/nfs4state.c

2042

static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)

fs/nfs/nfs4state.c

2044

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

2052

(unsigned long long)server->fsid.major,

fs/nfs/nfs4state.c

2053

(unsigned long long)server->fsid.minor,

fs/nfs/nfs4state.c

2066

inode = d_inode(server->super->s_root);

fs/nfs/nfs4state.c

2067

result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,

fs/nfs/nfs4state.c

2091

status = nfs4_replace_transport(server, locations);

fs/nfs/nfs4state.c

2110

set_bit(NFS_MIG_FAILED, &server->mig_status);

fs/nfs/nfs4state.c

2122

struct nfs_server *server;

fs/nfs/nfs4state.c

2135

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/nfs4state.c

2138

if (server->mig_gen == clp->cl_mig_gen)

fs/nfs/nfs4state.c

2140

server->mig_gen = clp->cl_mig_gen;

fs/nfs/nfs4state.c

2143

&server->mig_status))

fs/nfs/nfs4state.c

2147

status = nfs4_try_migration(server, cred);

fs/nfs/nfs4state.c

2168

struct nfs_server *server;

fs/nfs/nfs4state.c

2181

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/nfs4state.c

2185

if (server->mig_gen == clp->cl_mig_gen)

fs/nfs/nfs4state.c

2187

server->mig_gen = clp->cl_mig_gen;

fs/nfs/nfs4state.c

2191

inode = d_inode(server->super->s_root);

fs/nfs/nfs4state.c

2195

if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)

fs/nfs/nfs4state.c

355

nfs4_find_state_owner_locked(struct nfs_server *server, const struct cred *cred)

fs/nfs/nfs4state.c

357

struct rb_node **p = &server->state_owners.rb_node,

fs/nfs/nfs4state.c

384

struct nfs_server *server = new->so_server;

fs/nfs/nfs4state.c

385

struct rb_node **p = &server->state_owners.rb_node,

fs/nfs/nfs4state.c

407

rb_insert_color(&new->so_server_node, &server->state_owners);

fs/nfs/nfs4state.c

414

struct nfs_server *server = sp->so_server;

fs/nfs/nfs4state.c

417

rb_erase(&sp->so_server_node, &server->state_owners);

fs/nfs/nfs4state.c

443

nfs4_alloc_state_owner(struct nfs_server *server,

fs/nfs/nfs4state.c

452

sp->so_seqid.owner_id = atomic64_inc_return(&server->owner_ctr);

fs/nfs/nfs4state.c

453

sp->so_server = server;

fs/nfs/nfs4state.c

486

static void nfs4_gc_state_owners(struct nfs_server *server)

fs/nfs/nfs4state.c

488

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

496

list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {

fs/nfs/nfs4state.c

519

struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,

fs/nfs/nfs4state.c

523

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

527

sp = nfs4_find_state_owner_locked(server, cred);

fs/nfs/nfs4state.c

531

new = nfs4_alloc_state_owner(server, cred, gfp_flags);

fs/nfs/nfs4state.c

540

nfs4_gc_state_owners(server);

fs/nfs/nfs4state.c

558

struct nfs_server *server = sp->so_server;

fs/nfs/nfs4state.c

559

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

565

list_add_tail(&sp->so_lru, &server->state_owners_lru);

fs/nfs/nfs4state.c

580

void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head)

fs/nfs/nfs4state.c

582

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

586

list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {

fs/nfs/nfs4state.c

816

struct nfs_server *server = state->owner->so_server;

fs/nfs/nfs4state.c

825

lsp->ls_seqid.owner_id = atomic64_inc_return(&server->owner_ctr);

fs/nfs/nfs4state.c

830

void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)

fs/nfs/nfs4state.c

874

struct nfs_server *server;

fs/nfs/nfs4state.c

886

server = state->owner->so_server;

fs/nfs/nfs4state.c

888

struct nfs_client *clp = server->nfs_client;

fs/nfs/nfs4state.c

890

clp->cl_mvops->free_lock_state(server, lsp);

fs/nfs/nfs4state.c

892

nfs4_free_lock_state(server, lsp);

fs/nfs/nfs4super.c

142

static int do_nfs4_mount(struct nfs_server *server,

fs/nfs/nfs4super.c

155

if (IS_ERR(server))

fs/nfs/nfs4super.c

156

return PTR_ERR(server);

fs/nfs/nfs4super.c

160

nfs_free_server(server);

fs/nfs/nfs4super.c

169

root_ctx->server = server;

fs/nfs/nfs4trace.h

1047

__entry->dev = res->server->s_dev;

fs/nfs/nfs4trace.h

1353

const struct nfs_server *server,

fs/nfs/nfs4trace.h

1359

TP_ARGS(server, fhandle, fattr, error),

fs/nfs/nfs4trace.h

1370

__entry->dev = server->s_dev;

fs/nfs/nfs4trace.h

1392

const struct nfs_server *server, \

fs/nfs/nfs4trace.h

1397

TP_ARGS(server, fhandle, fattr, error))

fs/nfs/nfs4trace.h

2100

const struct nfs_server *server,

fs/nfs/nfs4trace.h

2105

TP_ARGS(server, deviceid, status),

fs/nfs/nfs4trace.h

2110

__string(dstaddr, server->nfs_client->cl_hostname)

fs/nfs/nfs4trace.h

2115

__entry->dev = server->s_dev;

fs/nfs/nfs4trace.h

2132

TP_PROTO(const struct nfs_server *server, \

fs/nfs/nfs4trace.h

2136

TP_ARGS(server, deviceid, status))

fs/nfs/nfs4trace.h

2142

const struct nfs_server *server,

fs/nfs/nfs4trace.h

2146

TP_ARGS(server, deviceid, ds_remotestr),

fs/nfs/nfs4trace.h

2149

__string(mds_addr, server->nfs_client->cl_hostname)

fs/nfs/nfs4xdr.c

1087

const struct nfs_server *server,

fs/nfs/nfs4xdr.c

1115

owner_namelen = nfs_map_uid_to_name(server, iap->ia_uid, owner_name, IDMAP_NAMESZ);

fs/nfs/nfs4xdr.c

1129

owner_grouplen = nfs_map_gid_to_group(server, iap->ia_gid, owner_group, IDMAP_NAMESZ);

fs/nfs/nfs4xdr.c

1254

create->server, create->server->attr_bitmask);

fs/nfs/nfs4xdr.c

1428

*p++ = cpu_to_be32(arg->server->s_dev);

fs/nfs/nfs4xdr.c

1442

arg->server, arg->server->attr_bitmask);

fs/nfs/nfs4xdr.c

1447

arg->server, arg->server->attr_bitmask);

fs/nfs/nfs4xdr.c

1457

arg->server, arg->server->exclcreat_bitmask);

fs/nfs/nfs4xdr.c

1734

static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)

fs/nfs/nfs4xdr.c

1738

encode_attrs(xdr, arg->iap, arg->label, NULL, server,

fs/nfs/nfs4xdr.c

1739

server->attr_bitmask);

fs/nfs/nfs4xdr.c

2640

encode_setattr(xdr, args, args->server, &hdr);

fs/nfs/nfs4xdr.c

3812

struct nfs4_string *server;

fs/nfs/nfs4xdr.c

3830

server = &loc->servers[loc->nservers];

fs/nfs/nfs4xdr.c

3831

status = decode_opaque_inline(xdr, &server->len, &server->data);

fs/nfs/nfs4xdr.c

3834

dprintk("%s ", server->data);

fs/nfs/nfs4xdr.c

4009

const struct nfs_server *server, kuid_t *uid,

fs/nfs/nfs4xdr.c

4031

if (len <= 0 || nfs_map_name_to_uid(server, p, len, uid) != 0)

fs/nfs/nfs4xdr.c

4043

const struct nfs_server *server, kgid_t *gid,

fs/nfs/nfs4xdr.c

4065

if (len <= 0 || nfs_map_group_to_gid(server, p, len, gid) != 0)

fs/nfs/nfs4xdr.c

4721

struct nfs4_fs_locations *fs_loc, const struct nfs_server *server)

fs/nfs/nfs4xdr.c

4788

status = decode_attr_owner(xdr, bitmap, server, &fattr->uid, fattr->owner_name);

fs/nfs/nfs4xdr.c

4793

status = decode_attr_group(xdr, bitmap, server, &fattr->gid, fattr->group_name);

fs/nfs/nfs4xdr.c

4853

const struct nfs_server *server)

fs/nfs/nfs4xdr.c

4872

status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);

fs/nfs/nfs4xdr.c

4883

const struct nfs_server *server)

fs/nfs/nfs4xdr.c

4885

return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);

fs/nfs/nfs4xdr.c

6317

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6347

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6377

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6404

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6498

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6528

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6566

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6668

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6704

decode_getfattr(xdr, res->f_attr, res->server);

fs/nfs/nfs4xdr.c

6758

decode_getfattr(xdr, res->f_attr, res->server);

fs/nfs/nfs4xdr.c

6788

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

6979

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

7179

status = decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

7213

res->fs_locations->server);

fs/nfs/nfs4xdr.c

7226

res->fs_locations->server);

fs/nfs/nfs4xdr.c

7517

decode_getfattr(xdr, res->fattr, res->server);

fs/nfs/nfs4xdr.c

7651

NULL, entry->server) < 0)

fs/nfs/pnfs.c

1000

if (pnfs_layout_bulk_destroy_byserver_locked(clp, server,

fs/nfs/pnfs.c

1011

struct nfs_server *server;

fs/nfs/pnfs.c

1015

server = NFS_SERVER(lo->plh_inode);

fs/nfs/pnfs.c

1021

server->caps &= ~NFS_CAP_REBOOT_LAYOUTRETURN;

fs/nfs/pnfs.c

1114

struct nfs_server *server;

fs/nfs/pnfs.c

1117

server = NFS_SERVER(inode);

fs/nfs/pnfs.c

1120

server = NFS_SERVER(parent_dir->d_inode);

fs/nfs/pnfs.c

1123

return server;

fs/nfs/pnfs.c

1171

struct nfs_server *server = pnfs_find_server(ino, ctx);

fs/nfs/pnfs.c

1172

size_t max_reply_sz = server->pnfs_curr_ld->max_layoutget_response;

fs/nfs/pnfs.c

1173

size_t max_pages = max_response_pages(server);

fs/nfs/pnfs.c

1214

lgp->args.type = server->pnfs_curr_ld->id;

fs/nfs/pnfs.c

161

set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,

fs/nfs/pnfs.c

170

if (!(server->nfs_client->cl_exchange_flags &

fs/nfs/pnfs.c

173

__func__, server->nfs_client->cl_exchange_flags);

fs/nfs/pnfs.c

197

server->pnfs_curr_ld = ld_type;

fs/nfs/pnfs.c

199

&& ld_type->set_layoutdriver(server, mntfh)) {

fs/nfs/pnfs.c

206

atomic_inc(&server->nfs_client->cl_mds_count);

fs/nfs/pnfs.c

2101

struct nfs_server *server)

fs/nfs/pnfs.c

2104

struct nfs_client *clp = server->nfs_client;

fs/nfs/pnfs.c

2110

list_add_tail_rcu(&lo->plh_layouts, &server->layouts);

fs/nfs/pnfs.c

213

server->pnfs_curr_ld = NULL;

fs/nfs/pnfs.c

2134

struct nfs_server *server = NFS_SERVER(ino);

fs/nfs/pnfs.c

2135

struct nfs_client *clp = server->nfs_client;

fs/nfs/pnfs.c

2274

nfs4_schedule_stateid_recovery(server, ctx->state);

fs/nfs/pnfs.c

2292

_add_to_server_list(lo, server);

fs/nfs/pnfs.c

2483

struct nfs_server *server = NFS_SERVER(data->dir->d_inode);

fs/nfs/pnfs.c

2485

if (!(pnfs_enabled_sb(server) &&

fs/nfs/pnfs.c

2486

server->pnfs_curr_ld->flags & PNFS_LAYOUTGET_ON_OPEN))

fs/nfs/pnfs.c

2660

struct nfs_server *server = NFS_SERVER(lo->plh_inode);

fs/nfs/pnfs.c

2683

pnfs_lseg_cancel_io(server, lseg);

fs/nfs/pnfs.c

280

struct nfs_server *server = NFS_SERVER(lo->plh_inode);

fs/nfs/pnfs.c

2807

static int pnfs_layout_return_unused_byserver(struct nfs_server *server,

fs/nfs/pnfs.c

281

struct pnfs_layoutdriver_type *ld = server->pnfs_curr_ld;

fs/nfs/pnfs.c

2819

list_for_each_entry_rcu(lo, &server->layouts, plh_layouts) {

fs/nfs/pnfs.c

284

struct nfs_client *clp = server->nfs_client;

fs/nfs/pnfs.c

3408

data->res.server = NFS_SERVER(inode);

fs/nfs/pnfs.c

3466

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/pnfs.c

3472

if (!pnfs_enabled_sb(server) || !ld->prepare_layoutstats)

fs/nfs/pnfs.c

726

struct nfs_server *server = NFS_SERVER(lo->plh_inode);

fs/nfs/pnfs.c

742

pnfs_lseg_cancel_io(server, lseg);

fs/nfs/pnfs.c

846

struct nfs_server *server,

fs/nfs/pnfs.c

854

list_for_each_entry_safe(lo, next, &server->layouts, plh_layouts) {

fs/nfs/pnfs.c

860

if (!nfs_sb_active(server->super))

fs/nfs/pnfs.c

874

nfs_sb_deactive(server->super);

fs/nfs/pnfs.c

923

struct nfs_server *server;

fs/nfs/pnfs.c

929

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/pnfs.c

930

if (memcmp(&server->fsid, fsid, sizeof(*fsid)) != 0)

fs/nfs/pnfs.c

933

server,

fs/nfs/pnfs.c

946

struct nfs_server *server;

fs/nfs/pnfs.c

951

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/pnfs.c

952

if (pnfs_layout_bulk_destroy_byserver_locked(clp, server,

fs/nfs/pnfs.c

992

struct nfs_server *server;

fs/nfs/pnfs.c

997

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/pnfs.c

998

if (!(server->caps & NFS_CAP_REBOOT_LAYOUTRETURN))

fs/nfs/pnfs.h

171

(struct nfs_server *server, struct pnfs_device *pdev,

fs/nfs/pnfs.h

252

extern size_t max_response_pages(struct nfs_server *server);

fs/nfs/pnfs.h

253

extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,

fs/nfs/pnfs.h

379

nfs4_find_get_deviceid(struct nfs_server *server,

fs/nfs/pnfs.h

690

static inline void pnfs_lseg_cancel_io(struct nfs_server *server,

fs/nfs/pnfs.h

693

if (server->pnfs_curr_ld->cancel_io)

fs/nfs/pnfs.h

694

server->pnfs_curr_ld->cancel_io(lseg);

fs/nfs/pnfs_dev.c

112

max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;

fs/nfs/pnfs_dev.c

115

__func__, server, max_resp_sz, max_pages);

fs/nfs/pnfs_dev.c

132

pdev->layout_type = server->pnfs_curr_ld->id;

fs/nfs/pnfs_dev.c

139

rc = nfs4_proc_getdeviceinfo(server, pdev, cred);

fs/nfs/pnfs_dev.c

148

d = server->pnfs_curr_ld->alloc_deviceid_node(server, pdev,

fs/nfs/pnfs_dev.c

170

__nfs4_find_get_deviceid(struct nfs_server *server,

fs/nfs/pnfs_dev.c

176

d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,

fs/nfs/pnfs_dev.c

185

nfs4_find_get_deviceid(struct nfs_server *server,

fs/nfs/pnfs_dev.c

192

d = __nfs4_find_get_deviceid(server, id, hash);

fs/nfs/pnfs_dev.c

196

new = nfs4_get_device_info(server, id, cred, gfp_mask);

fs/nfs/pnfs_dev.c

198

trace_nfs4_find_deviceid(server, id, -ENOENT);

fs/nfs/pnfs_dev.c

203

d = __nfs4_find_get_deviceid(server, id, hash);

fs/nfs/pnfs_dev.c

206

server->pnfs_curr_ld->free_deviceid_node(new);

fs/nfs/pnfs_dev.c

214

trace_nfs4_find_deviceid(server, id, 0);

fs/nfs/pnfs_dev.c

251

nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server,

fs/nfs/pnfs_dev.c

256

d->ld = server->pnfs_curr_ld;

fs/nfs/pnfs_dev.c

257

d->nfs_client = server->nfs_client;

fs/nfs/pnfs_dev.c

97

nfs4_get_device_info(struct nfs_server *server,

fs/nfs/proc.c

103

nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/proc.c

115

if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))

fs/nfs/proc.c

120

status = rpc_call_sync(server->client, &msg, task_flags);

fs/nfs/proc.c

536

nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/proc.c

54

nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/proc.c

549

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/proc.c

564

nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/proc.c

577

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/proc.c

595

nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,

fs/nfs/proc.c

68

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/proc.c

70

if (status && server->nfs_client->cl_rpcclient != server->client)

fs/nfs/proc.c

71

status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);

fs/nfs/proc.c

78

status = rpc_call_sync(server->client, &msg, 0);

fs/nfs/proc.c

80

if (status && server->nfs_client->cl_rpcclient != server->client)

fs/nfs/proc.c

81

status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);

fs/nfs/read.c

291

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/read.c

293

unsigned int rsize = server->rsize;

fs/nfs/read.c

68

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/read.c

72

if (server->pnfs_curr_ld && !force_mds)

fs/nfs/read.c

73

pg_ops = server->pnfs_curr_ld->pg_read_ops;

fs/nfs/read.c

76

server->rsize, 0);

fs/nfs/super.c

1070

struct nfs_server *server = NFS_SB(sb);

fs/nfs/super.c

1074

sb->s_xattr = server->nfs_client->cl_nfs_mod->xattr;

fs/nfs/super.c

1075

sb->s_op = server->nfs_client->cl_nfs_mod->sops;

fs/nfs/super.c

1076

if (server->bsize)

fs/nfs/super.c

1078

nfs_block_size(server->bsize, &sb->s_blocksize_bits);

fs/nfs/super.c

1080

switch (server->nfs_client->rpc_ops->version) {

fs/nfs/super.c

1102

if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)

fs/nfs/super.c

1114

sb->s_blocksize = nfs_block_bits(server->wsize,

fs/nfs/super.c

1117

nfs_super_set_maxbytes(sb, server->maxfilesize);

fs/nfs/super.c

1119

server->has_sec_mnt_opts = ctx->has_sec_mnt_opts;

fs/nfs/super.c

1156

struct nfs_server *server = fc->s_fs_info;

fs/nfs/super.c

1159

set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);

fs/nfs/super.c

1160

ret = set_anon_super(s, server);

fs/nfs/super.c

1162

server->s_dev = s->s_dev;

fs/nfs/super.c

1225

struct nfs_server *server = fc->s_fs_info, *old = NFS_SB(sb);

fs/nfs/super.c

1227

if (!nfs_compare_super_address(old, server))

fs/nfs/super.c

1232

if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)

fs/nfs/super.c

1234

if (!nfs_compare_userns(old, server))

fs/nfs/super.c

1239

return nfs_compare_mount_options(sb, server, fc);

fs/nfs/super.c

1287

struct nfs_server *server = ctx->server;

fs/nfs/super.c

1290

ctx->server = NULL;

fs/nfs/super.c

1291

if (IS_ERR(server))

fs/nfs/super.c

1292

return PTR_ERR(server);

fs/nfs/super.c

1294

if (server->flags & NFS_MOUNT_UNSHARED)

fs/nfs/super.c

1298

if (server->flags & NFS_MOUNT_NOAC)

fs/nfs/super.c

1302

fc->s_fs_info = server;

fs/nfs/super.c

1311

if (s->s_fs_info != server) {

fs/nfs/super.c

1312

nfs_free_server(server);

fs/nfs/super.c

1313

server = NULL;

fs/nfs/super.c

1315

error = super_setup_bdi_name(s, "%u:%u", MAJOR(server->s_dev),

fs/nfs/super.c

1316

MINOR(server->s_dev));

fs/nfs/super.c

1319

s->s_bdi->io_pages = server->rpages;

fs/nfs/super.c

1320

server->super = s;

fs/nfs/super.c

1344

nfs_free_server(server);

fs/nfs/super.c

1356

struct nfs_server *server = NFS_SB(s);

fs/nfs/super.c

1358

nfs_sysfs_move_sb_to_server(server);

fs/nfs/super.c

1363

nfs_free_server(server);

fs/nfs/super.c

196

struct nfs_server *server = NFS_SB(sb);

fs/nfs/super.c

200

if (atomic_inc_return(&server->active) != 1)

fs/nfs/super.c

208

struct nfs_server *server = NFS_SB(sb);

fs/nfs/super.c

210

if (atomic_dec_and_test(&server->active))

fs/nfs/super.c

216

int (*fn)(struct nfs_server *server, void *data), void *data)

fs/nfs/super.c

218

struct nfs_server *server, *last = NULL;

fs/nfs/super.c

222

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/super.c

223

if (!(server->super && nfs_sb_active(server->super)))

fs/nfs/super.c

228

last = server;

fs/nfs/super.c

229

ret = fn(server, data);

fs/nfs/super.c

248

struct nfs_server *server = NFS_SB(dentry->d_sb);

fs/nfs/super.c

259

error = server->nfs_client->rpc_ops->statfs(server, fh, &res);

fs/nfs/super.c

297

buf->f_namelen = server->namelen;

fs/nfs/super.c

582

static void show_lease(struct seq_file *m, struct nfs_server *server)

fs/nfs/super.c

584

struct nfs_client *clp = server->nfs_client;

fs/nfs/super.c

593

static void show_sessions(struct seq_file *m, struct nfs_server *server)

fs/nfs/super.c

595

if (nfs4_has_session(server->nfs_client))

fs/nfs/super.c

599

static void show_pnfs(struct seq_file *m, struct nfs_server *server)

fs/nfs/super.c

602

if (server->pnfs_curr_ld)

fs/nfs/super.c

603

seq_printf(m, "%s", server->pnfs_curr_ld->name);

fs/nfs/super.c

738

struct nfs_server *server;

fs/nfs/super.c

741

server = NFS_SB(sb);

fs/nfs/super.c

743

rpc = server->client_acl;

fs/nfs/super.c

746

rpc = server->client;

fs/nfs/super.c

900

struct nfs_server *server = ERR_PTR(-EACCES);

fs/nfs/super.c

955

server = ctx->nfs_mod->rpc_ops->create_server(fc);

fs/nfs/super.c

956

if (!IS_ERR(server))

fs/nfs/super.c

957

return server;

fs/nfs/super.c

966

return server;

fs/nfs/super.c

979

ctx->server = nfs_try_mount_request(fc);

fs/nfs/super.c

981

ctx->server = ctx->nfs_mod->rpc_ops->create_server(fc);

fs/nfs/sysfs.c

239

struct nfs_server *server;

fs/nfs/sysfs.c

241

list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

fs/nfs/sysfs.c

242

if (!(server->flags & NFS_MOUNT_SHUTDOWN)) {

fs/nfs/sysfs.c

256

struct nfs_server *server = container_of(kobj, struct nfs_server, kobj);

fs/nfs/sysfs.c

257

bool shutdown = server->flags & NFS_MOUNT_SHUTDOWN;

fs/nfs/sysfs.c

265

struct nfs_server *server;

fs/nfs/sysfs.c

268

server = container_of(kobj, struct nfs_server, kobj);

fs/nfs/sysfs.c

278

if (server->flags & NFS_MOUNT_SHUTDOWN)

fs/nfs/sysfs.c

281

server->flags |= NFS_MOUNT_SHUTDOWN;

fs/nfs/sysfs.c

282

shutdown_client(server->client);

fs/nfs/sysfs.c

284

if (!IS_ERR(server->client_acl))

fs/nfs/sysfs.c

285

shutdown_client(server->client_acl);

fs/nfs/sysfs.c

287

if (server->nlm_host)

fs/nfs/sysfs.c

288

shutdown_client(server->nlm_host->h_rpcclnt);

fs/nfs/sysfs.c

290

shutdown_nfs_client(server->nfs_client);

fs/nfs/sysfs.c

301

struct nfs_server *server = container_of(kobj, struct nfs_server, kobj);

fs/nfs/sysfs.c

302

struct nfs41_impl_id *impl_id = server->nfs_client->cl_implid;

fs/nfs/sysfs.c

316

struct nfs_server *server = container_of(kobj, struct nfs_server, kobj);

fs/nfs/sysfs.c

317

struct nfs41_impl_id *impl_id = server->nfs_client->cl_implid;

fs/nfs/sysfs.c

330

void nfs_sysfs_link_rpc_client(struct nfs_server *server,

fs/nfs/sysfs.c

340

ret = sysfs_create_link_nowarn(&server->kobj,

fs/nfs/sysfs.c

366

static void nfs_sysfs_add_nfsv41_server(struct nfs_server *server)

fs/nfs/sysfs.c

370

if (!server->nfs_client->cl_implid)

fs/nfs/sysfs.c

373

ret = sysfs_create_file_ns(&server->kobj, &nfs_sysfs_attr_implid_domain.attr,

fs/nfs/sysfs.c

374

nfs_netns_server_namespace(&server->kobj));

fs/nfs/sysfs.c

377

server->s_sysfs_id, ret);

fs/nfs/sysfs.c

379

ret = sysfs_create_file_ns(&server->kobj, &nfs_sysfs_attr_implid_name.attr,

fs/nfs/sysfs.c

380

nfs_netns_server_namespace(&server->kobj));

fs/nfs/sysfs.c

383

server->s_sysfs_id, ret);

fs/nfs/sysfs.c

386

static inline void nfs_sysfs_add_nfsv41_server(struct nfs_server *server)

fs/nfs/sysfs.c

397

struct nfs_server *server = container_of(kobj, struct nfs_server, kobj);

fs/nfs/sysfs.c

398

bool localio = nfs_server_is_local(server->nfs_client);

fs/nfs/sysfs.c

404

static void nfs_sysfs_add_nfs_localio_server(struct nfs_server *server)

fs/nfs/sysfs.c

406

int ret = sysfs_create_file_ns(&server->kobj, &nfs_sysfs_attr_localio.attr,

fs/nfs/sysfs.c

407

nfs_netns_server_namespace(&server->kobj));

fs/nfs/sysfs.c

410

server->s_sysfs_id, ret);

fs/nfs/sysfs.c

413

static inline void nfs_sysfs_add_nfs_localio_server(struct nfs_server *server)

fs/nfs/sysfs.c

418

void nfs_sysfs_add_server(struct nfs_server *server)

fs/nfs/sysfs.c

422

ret = kobject_init_and_add(&server->kobj, &nfs_sb_ktype,

fs/nfs/sysfs.c

423

&nfs_kset->kobj, "server-%d", server->s_sysfs_id);

fs/nfs/sysfs.c

426

server->s_sysfs_id, ret);

fs/nfs/sysfs.c

429

ret = sysfs_create_file_ns(&server->kobj, &nfs_sysfs_attr_shutdown.attr,

fs/nfs/sysfs.c

430

nfs_netns_server_namespace(&server->kobj));

fs/nfs/sysfs.c

433

server->s_sysfs_id, ret);

fs/nfs/sysfs.c

435

nfs_sysfs_add_nfsv41_server(server);

fs/nfs/sysfs.c

436

nfs_sysfs_add_nfs_localio_server(server);

fs/nfs/sysfs.c

442

struct nfs_server *server = s->s_fs_info;

fs/nfs/sysfs.c

445

ret = kobject_rename(&server->kobj, s->s_id);

fs/nfs/sysfs.c

448

server->kobj.name, ret);

fs/nfs/sysfs.c

451

void nfs_sysfs_move_sb_to_server(struct nfs_server *server)

fs/nfs/sysfs.c

456

s = kasprintf(GFP_KERNEL, "server-%d", server->s_sysfs_id);

fs/nfs/sysfs.c

458

ret = kobject_rename(&server->kobj, s);

fs/nfs/sysfs.c

463

server->kobj.name, ret);

fs/nfs/sysfs.c

467

void nfs_sysfs_remove_server(struct nfs_server *server)

fs/nfs/sysfs.c

469

kobject_del(&server->kobj);

fs/nfs/sysfs.h

26

void nfs_sysfs_link_rpc_client(struct nfs_server *server,

fs/nfs/write.c

1402

struct nfs_server *server = NFS_SERVER(inode);

fs/nfs/write.c

1406

if (server->pnfs_curr_ld && !force_mds)

fs/nfs/write.c

1407

pg_ops = server->pnfs_curr_ld->pg_write_ops;

fs/nfs/write.c

1410

server->wsize, ioflags);

fs/nfs_common/localio_trace.h

27

__string(server, clp->cl_hostname)

fs/nfs_common/localio_trace.h

32

__assign_str(server);

fs/nfs_common/localio_trace.h

36

"server=%s NFSv%u", __get_str(server), __entry->protocol

fs/nfsd/trace.h

25

__sockaddr(server, (r)->rq_xprt->xpt_locallen) \

fs/nfsd/trace.h

274

__sockaddr(server, rqstp->rq_xprt->xpt_remotelen)

fs/nfsd/trace.h

284

__assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,

fs/nfsd/trace.h

313

__sockaddr(server, rqstp->rq_xprt->xpt_remotelen)

fs/nfsd/trace.h

324

__assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,

fs/nfsd/trace.h

33

__assign_sockaddr(server, &xprt->xpt_local, \

fs/nfsd/trace.h

43

__sockaddr(server, (r)->rq_xprt->xpt_locallen) \

fs/nfsd/trace.h

52

__assign_sockaddr(server, &xprt->xpt_local, \

fs/nfsd/trace.h

68

__sockaddr(server, rqstp->rq_xprt->xpt_locallen)

fs/nfsd/trace.h

78

__assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);

fs/smb/client/asn1.c

13

struct TCP_Server_Info *server)

fs/smb/client/asn1.c

15

if (asn1_ber_decoder(&cifs_spnego_negtokeninit_decoder, server,

fs/smb/client/asn1.c

43

struct TCP_Server_Info *server = context;

fs/smb/client/asn1.c

48

server->sec_mskerberos = true;

fs/smb/client/asn1.c

50

server->sec_kerberosu2u = true;

fs/smb/client/asn1.c

52

server->sec_kerberos = true;

fs/smb/client/asn1.c

54

server->sec_ntlmssp = true;

fs/smb/client/asn1.c

56

server->sec_iakerb = true;

fs/smb/client/cached_dir.c

140

struct TCP_Server_Info *server;

fs/smb/client/cached_dir.c

176

server = cifs_pick_channel(ses);

fs/smb/client/cached_dir.c

178

if (!server->ops->new_lease_key)

fs/smb/client/cached_dir.c

229

if (dentry->d_parent && server->dialect >= SMB30_PROT_ID) {

fs/smb/client/cached_dir.c

262

server->ops->new_lease_key(pfid);

fs/smb/client/cached_dir.c

285

rc = SMB2_open_init(tcon, server,

fs/smb/client/cached_dir.c

295

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/cached_dir.c

311

smb2_set_replay(server, &rqst[0]);

fs/smb/client/cached_dir.c

312

smb2_set_replay(server, &rqst[1]);

fs/smb/client/cached_dir.c

315

rc = compound_send_recv(xid, ses, server,

fs/smb/client/cached_dir.c

344

rc = smb2_parse_contexts(server, rsp_iov,

fs/smb/client/cifs_debug.c

105

if (tcon->ses->server->ops->dump_share_caps)

fs/smb/client/cifs_debug.c

106

tcon->ses->server->ops->dump_share_caps(m, tcon);

fs/smb/client/cifs_debug.c

125

struct TCP_Server_Info *server = chan->server;

fs/smb/client/cifs_debug.c

127

if (!server) {

fs/smb/client/cifs_debug.c

137

i+1, server->conn_id,

fs/smb/client/cifs_debug.c

138

server->credits,

fs/smb/client/cifs_debug.c

139

server->echo_credits,

fs/smb/client/cifs_debug.c

140

server->oplock_credits,

fs/smb/client/cifs_debug.c

141

server->dialect,

fs/smb/client/cifs_debug.c

142

server->tcpStatus,

fs/smb/client/cifs_debug.c

143

server->reconnect_instance,

fs/smb/client/cifs_debug.c

144

server->srv_count,

fs/smb/client/cifs_debug.c

145

server->sec_mode,

fs/smb/client/cifs_debug.c

146

in_flight(server),

fs/smb/client/cifs_debug.c

147

atomic_read(&server->in_send),

fs/smb/client/cifs_debug.c

148

atomic_read(&server->num_waiters));

fs/smb/client/cifs_debug.c

150

if (server->net)

fs/smb/client/cifs_debug.c

151

seq_printf(m, " Net namespace: %u ", server->net->ns.inum);

fs/smb/client/cifs_debug.c

223

struct TCP_Server_Info *server;

fs/smb/client/cifs_debug.c

241

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/cifs_debug.c

242

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/cifs_debug.c

302

struct TCP_Server_Info *server;

fs/smb/client/cifs_debug.c

315

server = list_entry(stmp, struct TCP_Server_Info,

fs/smb/client/cifs_debug.c

317

list_for_each(tmp, &server->smb_ses_list) {

fs/smb/client/cifs_debug.c

39

void cifs_dump_mids(struct TCP_Server_Info *server)

fs/smb/client/cifs_debug.c

394

struct TCP_Server_Info *server;

fs/smb/client/cifs_debug.c

44

if (server == NULL)

fs/smb/client/cifs_debug.c

454

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/cifs_debug.c

461

if (SERVER_IS_CHAN(server))

fs/smb/client/cifs_debug.c

466

c, server->conn_id);

fs/smb/client/cifs_debug.c

468

spin_lock(&server->srv_lock);

fs/smb/client/cifs_debug.c

469

if (server->hostname)

fs/smb/client/cifs_debug.c

470

seq_printf(m, "Hostname: %s ", server->hostname);

fs/smb/client/cifs_debug.c

471

seq_printf(m, "\nClientGUID: %pUL", server->client_guid);

fs/smb/client/cifs_debug.c

472

spin_unlock(&server->srv_lock);

fs/smb/client/cifs_debug.c

474

if (!server->rdma)

fs/smb/client/cifs_debug.c

477

if (!server->smbd_conn) {

fs/smb/client/cifs_debug.c

48

spin_lock(&server->mid_queue_lock);

fs/smb/client/cifs_debug.c

481

sc = &server->smbd_conn->socket;

fs/smb/client/cifs_debug.c

49

list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {

fs/smb/client/cifs_debug.c

503

server->rdma_readwrite_threshold);

fs/smb/client/cifs_debug.c

536

server->credits,

fs/smb/client/cifs_debug.c

537

server->echo_credits,

fs/smb/client/cifs_debug.c

538

server->oplock_credits,

fs/smb/client/cifs_debug.c

539

server->dialect);

fs/smb/client/cifs_debug.c

540

if (server->sign)

fs/smb/client/cifs_debug.c

542

if (server->posix_ext_supported)

fs/smb/client/cifs_debug.c

544

if (server->nosharesock)

fs/smb/client/cifs_debug.c

547

seq_printf(m, "\nServer capabilities: 0x%x", server->capabilities);

fs/smb/client/cifs_debug.c

549

if (server->rdma)

fs/smb/client/cifs_debug.c

553

server->tcpStatus,

fs/smb/client/cifs_debug.c

554

server->reconnect_instance,

fs/smb/client/cifs_debug.c

555

server->srv_count,

fs/smb/client/cifs_debug.c

556

server->sec_mode, in_flight(server));

fs/smb/client/cifs_debug.c

558

if (server->net)

fs/smb/client/cifs_debug.c

559

seq_printf(m, " Net namespace: %u ", server->net->ns.inum);

fs/smb/client/cifs_debug.c

563

atomic_read(&server->in_send),

fs/smb/client/cifs_debug.c

564

atomic_read(&server->num_waiters));

fs/smb/client/cifs_debug.c

566

if (server->leaf_fullpath) {

fs/smb/client/cifs_debug.c

568

server->leaf_fullpath);

fs/smb/client/cifs_debug.c

574

else if (!server->compression.requested)

fs/smb/client/cifs_debug.c

576

else if (server->compression.enabled)

fs/smb/client/cifs_debug.c

577

seq_printf(m, "enabled (%s)", compression_alg_str(server->compression.alg));

fs/smb/client/cifs_debug.c

583

if (server->cipher_type)

fs/smb/client/cifs_debug.c

584

seq_printf(m, "Negotiated cipher (%s)", cipher_alg_str(server->cipher_type));

fs/smb/client/cifs_debug.c

588

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/cifs_debug.c

619

get_security_type_str(server->ops->select_sectype(server, ses->sectype)));

fs/smb/client/cifs_debug.c

66

server->ops->dump_detail(mid_entry->resp_buf,

fs/smb/client/cifs_debug.c

67

mid_entry->response_pdu_len, server);

fs/smb/client/cifs_debug.c

704

chan_server = ses->chans[j].server;

fs/smb/client/cifs_debug.c

71

spin_unlock(&server->mid_queue_lock);

fs/smb/client/cifs_debug.c

746

struct TCP_Server_Info *server;

fs/smb/client/cifs_debug.c

766

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/cifs_debug.c

767

server->max_in_flight = 0;

fs/smb/client/cifs_debug.c

770

atomic_set(&server->num_cmds[i], 0);

fs/smb/client/cifs_debug.c

771

atomic_set(&server->smb2slowcmd[i], 0);

fs/smb/client/cifs_debug.c

772

server->time_per_cmd[i] = 0;

fs/smb/client/cifs_debug.c

773

server->slowest_cmd[i] = 0;

fs/smb/client/cifs_debug.c

774

server->fastest_cmd[0] = 0;

fs/smb/client/cifs_debug.c

777

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/cifs_debug.c

787

if (server->ops->clear_stats)

fs/smb/client/cifs_debug.c

788

server->ops->clear_stats(tcon);

fs/smb/client/cifs_debug.c

806

struct TCP_Server_Info *server;

fs/smb/client/cifs_debug.c

836

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/cifs_debug.c

837

seq_printf(m, "\nMax requests in flight: %d", server->max_in_flight);

fs/smb/client/cifs_debug.c

845

atomic_read(&server->num_cmds[j]),

fs/smb/client/cifs_debug.c

846

server->time_per_cmd[j],

fs/smb/client/cifs_debug.c

847

server->fastest_cmd[j],

fs/smb/client/cifs_debug.c

848

server->slowest_cmd[j]);

fs/smb/client/cifs_debug.c

850

if (atomic_read(&server->smb2slowcmd[j])) {

fs/smb/client/cifs_debug.c

851

spin_lock(&server->srv_lock);

fs/smb/client/cifs_debug.c

853

atomic_read(&server->smb2slowcmd[j]),

fs/smb/client/cifs_debug.c

854

server->hostname, j);

fs/smb/client/cifs_debug.c

855

spin_unlock(&server->srv_lock);

fs/smb/client/cifs_debug.c

858

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/cifs_debug.c

869

if (server->ops->print_stats)

fs/smb/client/cifs_debug.c

870

server->ops->print_stats(m, tcon);

fs/smb/client/cifs_debug.h

146

server->hostname, ##__VA_ARGS__); \

fs/smb/client/cifs_debug.h

18

void cifs_dump_mids(struct TCP_Server_Info *server);

fs/smb/client/cifs_debug.h

83

spin_lock(&server->srv_lock); \

fs/smb/client/cifs_debug.h

86

__FILE__, server->hostname, \

fs/smb/client/cifs_debug.h

90

server->hostname, ##__VA_ARGS__); \

fs/smb/client/cifs_debug.h

93

server->hostname, ##__VA_ARGS__); \

fs/smb/client/cifs_debug.h

95

spin_unlock(&server->srv_lock); \

fs/smb/client/cifs_spnego.c

124

if (server->dstaddr.ss_family == AF_INET)

fs/smb/client/cifs_spnego.c

126

else if (server->dstaddr.ss_family == AF_INET6)

fs/smb/client/cifs_spnego.c

132

if (server->sec_kerberos)

fs/smb/client/cifs_spnego.c

134

else if (server->sec_mskerberos)

fs/smb/client/cifs_spnego.c

136

else if (server->sec_iakerb)

fs/smb/client/cifs_spnego.c

162

trace_smb3_kerberos_auth(server, sesInfo, PTR_ERR_OR_ZERO(spnego_key));

fs/smb/client/cifs_spnego.c

85

struct TCP_Server_Info *server)

fs/smb/client/cifs_spnego.c

87

struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;

fs/smb/client/cifs_spnego.c

88

struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;

fs/smb/client/cifs_spnego.c

92

const char *hostname = server->hostname;

fs/smb/client/cifs_spnego.h

32

struct TCP_Server_Info *server);

fs/smb/client/cifs_swn.c

112

if (swnreg->tcon->ses->server->use_swn_dstaddr)

fs/smb/client/cifs_swn.c

113

addr = &swnreg->tcon->ses->server->swn_dstaddr;

fs/smb/client/cifs_swn.c

115

addr = &swnreg->tcon->ses->server->dstaddr;

fs/smb/client/cifs_swn.c

139

authtype = cifs_select_sectype(swnreg->tcon->ses->server, swnreg->tcon->ses->sectype);

fs/smb/client/cifs_swn.c

208

&swnreg->tcon->ses->server->dstaddr);

fs/smb/client/cifs_swn.c

395

cifs_signal_cifsd_for_reconnect(swnreg->tcon->ses->server, true);

fs/smb/client/cifs_swn.c

399

cifs_signal_cifsd_for_reconnect(swnreg->tcon->ses->server, true);

fs/smb/client/cifs_swn.c

464

cifs_server_lock(tcon->ses->server);

fs/smb/client/cifs_swn.c

465

if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))

fs/smb/client/cifs_swn.c

468

ret = cifs_swn_store_swn_addr(addr, &tcon->ses->server->dstaddr,

fs/smb/client/cifs_swn.c

469

&tcon->ses->server->swn_dstaddr);

fs/smb/client/cifs_swn.c

474

tcon->ses->server->use_swn_dstaddr = true;

fs/smb/client/cifs_swn.c

497

cifs_signal_cifsd_for_reconnect(tcon->ses->server, false);

fs/smb/client/cifs_swn.c

500

cifs_server_unlock(tcon->ses->server);

fs/smb/client/cifs_swn.c

637

switch (swnreg->tcon->ses->server->dstaddr.ss_family) {

fs/smb/client/cifs_swn.c

639

sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;

fs/smb/client/cifs_swn.c

643

sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;

fs/smb/client/cifs_swn.h

27

static inline bool cifs_swn_set_server_dstaddr(struct TCP_Server_Info *server)

fs/smb/client/cifs_swn.h

29

if (server->use_swn_dstaddr) {

fs/smb/client/cifs_swn.h

30

server->dstaddr = server->swn_dstaddr;

fs/smb/client/cifs_swn.h

36

static inline void cifs_swn_reset_server_dstaddr(struct TCP_Server_Info *server)

fs/smb/client/cifs_swn.h

38

server->use_swn_dstaddr = false;

fs/smb/client/cifs_swn.h

48

static inline bool cifs_swn_set_server_dstaddr(struct TCP_Server_Info *server) { return false; }

fs/smb/client/cifs_swn.h

49

static inline void cifs_swn_reset_server_dstaddr(struct TCP_Server_Info *server) {}

fs/smb/client/cifsacl.c

1572

ops = tlink_tcon(tlink)->ses->server->ops;

fs/smb/client/cifsacl.c

1628

ops = tlink_tcon(tlink)->ses->server->ops;

fs/smb/client/cifsencrypt.c

266

wchar_t *server;

fs/smb/client/cifsencrypt.c

305

server = kmalloc(2 + (len * 2), GFP_KERNEL);

fs/smb/client/cifsencrypt.c

306

if (server == NULL)

fs/smb/client/cifsencrypt.c

309

len = cifs_strtoUTF16((__le16 *)server, ses->ip_addr, len, nls_cp);

fs/smb/client/cifsencrypt.c

310

hmac_md5_update(&hmac_ctx, (const u8 *)server, 2 * len);

fs/smb/client/cifsencrypt.c

311

kfree(server);

fs/smb/client/cifsencrypt.c

328

if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED)

fs/smb/client/cifsencrypt.c

331

memcpy(ntlmv2->challenge.key, ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);

fs/smb/client/cifsencrypt.c

347

struct TCP_Server_Info *server = ses->server;

fs/smb/client/cifsencrypt.c

353

spnlen = strlen(server->hostname);

fs/smb/client/cifsencrypt.c

362

(int)spnlen, server->hostname);

fs/smb/client/cifsencrypt.c

405

if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED) {

fs/smb/client/cifsencrypt.c

446

cifs_server_lock(ses->server);

fs/smb/client/cifsencrypt.c

485

cifs_server_unlock(ses->server);

fs/smb/client/cifsencrypt.c

524

cifs_crypto_secmech_release(struct TCP_Server_Info *server)

fs/smb/client/cifsencrypt.c

526

cifs_free_hash(&server->secmech.aes_cmac);

fs/smb/client/cifsencrypt.c

528

if (server->secmech.enc) {

fs/smb/client/cifsencrypt.c

529

crypto_free_aead(server->secmech.enc);

fs/smb/client/cifsencrypt.c

530

server->secmech.enc = NULL;

fs/smb/client/cifsencrypt.c

532

if (server->secmech.dec) {

fs/smb/client/cifsencrypt.c

533

crypto_free_aead(server->secmech.dec);

fs/smb/client/cifsencrypt.c

534

server->secmech.dec = NULL;

fs/smb/client/cifsencrypt.c

87

int __cifs_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,

fs/smb/client/cifsfs.c

1141

if (tcon->ses->server->ops->llseek)

fs/smb/client/cifsfs.c

1142

return tcon->ses->server->ops->llseek(file, tcon,

fs/smb/client/cifsfs.c

1274

if (src_tcon->ses->server->ops->set_file_size)

fs/smb/client/cifsfs.c

1275

rc = src_tcon->ses->server->ops->set_file_size(

fs/smb/client/cifsfs.c

133

struct TCP_Server_Info *server;

fs/smb/client/cifsfs.c

138

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/cifsfs.c

139

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/cifsfs.c

1416

if (target_tcon->ses->server->ops->duplicate_extents) {

fs/smb/client/cifsfs.c

1417

rc = target_tcon->ses->server->ops->duplicate_extents(xid,

fs/smb/client/cifsfs.c

1489

if (!target_tcon->ses->server->ops->copychunk_range)

fs/smb/client/cifsfs.c

1529

rc = target_tcon->ses->server->ops->copychunk_range(xid,

fs/smb/client/cifsfs.c

211

struct cifs_sb_info *server = CIFS_SB(sb);

fs/smb/client/cifsfs.c

213

if (atomic_inc_return(&server->active) == 1)

fs/smb/client/cifsfs.c

220

struct cifs_sb_info *server = CIFS_SB(sb);

fs/smb/client/cifsfs.c

222

if (atomic_dec_and_test(&server->active))

fs/smb/client/cifsfs.c

246

if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)

fs/smb/client/cifsfs.c

258

if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&

fs/smb/client/cifsfs.c

260

tcon->ses->server->vals->cap_nt_find) == 0) &&

fs/smb/client/cifsfs.c

289

tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);

fs/smb/client/cifsfs.c

359

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/cifsfs.c

387

if (server->ops->queryfs)

fs/smb/client/cifsfs.c

388

rc = server->ops->queryfs(xid, tcon, full_path, cifs_sb, buf);

fs/smb/client/cifsfs.c

399

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/cifsfs.c

403

if (!server->ops->fallocate)

fs/smb/client/cifsfs.c

416

rc = server->ops->fallocate(file, tcon, mode, off, len);

fs/smb/client/cifsfs.c

513

cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)

fs/smb/client/cifsfs.c

515

struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;

fs/smb/client/cifsfs.c

516

struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;

fs/smb/client/cifsfs.c

520

switch (server->dstaddr.ss_family) {

fs/smb/client/cifsfs.c

532

if (server->rdma)

fs/smb/client/cifsfs.c

647

srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;

fs/smb/client/cifsfs.c

649

seq_show_option(s, "vers", tcon->ses->server->vals->version_string);

fs/smb/client/cifsfs.c

695

cifs_show_address(s, tcon->ses->server);

fs/smb/client/cifsfs.c

709

else if (tcon->ses->server->ignore_signature)

fs/smb/client/cifsfs.c

797

if (tcon->ses->server->min_offload)

fs/smb/client/cifsfs.c

798

seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);

fs/smb/client/cifsfs.c

799

if (tcon->ses->server->retrans)

fs/smb/client/cifsfs.c

800

seq_printf(s, ",retrans=%u", tcon->ses->server->retrans);

fs/smb/client/cifsfs.c

802

tcon->ses->server->echo_interval / HZ);

fs/smb/client/cifsfs.c

805

if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)

fs/smb/client/cifsfs.c

806

seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);

fs/smb/client/cifsfs.c

807

if (tcon->ses->server->tcp_nodelay)

fs/smb/client/cifsfs.c

809

if (tcon->ses->server->noautotune)

fs/smb/client/cifsfs.c

811

if (tcon->ses->server->noblocksnd)

fs/smb/client/cifsfs.c

813

if (tcon->ses->server->nosharesock)

fs/smb/client/cifsfs.c

877

if (tcon->ses && tcon->ses->server) {

fs/smb/client/cifsfs.c

879

wake_up_all(&tcon->ses->server->request_q);

fs/smb/client/cifsfs.c

880

wake_up_all(&tcon->ses->server->response_q);

fs/smb/client/cifsfs.c

883

wake_up_all(&tcon->ses->server->response_q);

fs/smb/client/cifsglob.h

1047

struct TCP_Server_Info *server;

fs/smb/client/cifsglob.h

1066

struct TCP_Server_Info *server; /* pointer to server info */

fs/smb/client/cifsglob.h

1157

return ses->server->vals->cap_unix & ses->capabilities;

fs/smb/client/cifsglob.h

1479

struct TCP_Server_Info *server;

fs/smb/client/cifsglob.h

1503

struct TCP_Server_Info *server;

fs/smb/client/cifsglob.h

1687

typedef int (*mid_receive_t)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

1704

typedef int (*mid_handle_t)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

1753

static inline void cifs_in_send_inc(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

1755

atomic_inc(&server->in_send);

fs/smb/client/cifsglob.h

1758

static inline void cifs_in_send_dec(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

1760

atomic_dec(&server->in_send);

fs/smb/client/cifsglob.h

1763

static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

1765

atomic_inc(&server->num_waiters);

fs/smb/client/cifsglob.h

1768

static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

1770

atomic_dec(&server->num_waiters);

fs/smb/client/cifsglob.h

1817

struct TCP_Server_Info *server;

fs/smb/client/cifsglob.h

2183

static inline bool is_smb1_server(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

2185

return strcmp(server->vals->version_string, SMB1_VERSION_STRING) == 0;

fs/smb/client/cifsglob.h

2197

if (!tcon || !tcon->ses || !tcon->ses->server)

fs/smb/client/cifsglob.h

2199

return is_smb1_server(tcon->ses->server) ? tcon->Flags & SMB_SHARE_IS_IN_DFS :

fs/smb/client/cifsglob.h

2220

if (WARN_ON_ONCE(!ses || !ses->server))

fs/smb/client/cifsglob.h

2226

if (ses->server->dialect <= SMB20_PROT_ID)

fs/smb/client/cifsglob.h

2304

static inline void mid_execute_callback(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

2315

callback(server, mid);

fs/smb/client/cifsglob.h

2332

static inline void cifs_queue_server_reconn(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

2334

if (!delayed_work_pending(&server->reconnect)) {

fs/smb/client/cifsglob.h

2335

WRITE_ONCE(server->reconn_delay, 0);

fs/smb/client/cifsglob.h

2336

mod_delayed_work(cifsiod_wq, &server->reconnect, 0);

fs/smb/client/cifsglob.h

2340

static inline void cifs_requeue_server_reconn(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

2342

unsigned long delay = READ_ONCE(server->reconn_delay);

fs/smb/client/cifsglob.h

2345

WRITE_ONCE(server->reconn_delay, delay);

fs/smb/client/cifsglob.h

2346

queue_delayed_work(cifsiod_wq, &server->reconnect, delay * HZ);

fs/smb/client/cifsglob.h

314

int (*send_cancel)(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

328

void (*add_credits)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

335

void (*revert_current_mid)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

350

struct mid_q_entry *(*find_mid)(struct TCP_Server_Info *server, char *buf);

fs/smb/client/cifsglob.h

357

struct TCP_Server_Info *server);

fs/smb/client/cifsglob.h

360

void (*downgrade_oplock)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

371

struct TCP_Server_Info *server);

fs/smb/client/cifsglob.h

378

struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

515

bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server);

fs/smb/client/cifsglob.h

541

struct TCP_Server_Info *server);

fs/smb/client/cifsglob.h

589

int (*adjust_credits)(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

604

int (*next_header)(struct TCP_Server_Info *server, char *buf,

fs/smb/client/cifsglob.h

641

#define HEADER_SIZE(server) (server->vals->header_size)

fs/smb/client/cifsglob.h

642

#define MAX_HEADER_SIZE(server) (server->vals->max_header_size)

fs/smb/client/cifsglob.h

643

#define MID_HEADER_SIZE(server) (HEADER_SIZE(server) - 1)

fs/smb/client/cifsglob.h

820

#define SERVER_IS_CHAN(server) (!!(server)->primary_server)

fs/smb/client/cifsglob.h

839

static inline bool is_smb1(const struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

841

return server->vals->protocol_id == SMB10_PROT_ID;

fs/smb/client/cifsglob.h

844

static inline void cifs_server_lock(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

848

mutex_lock(&server->_srv_mutex);

fs/smb/client/cifsglob.h

849

server->nofs_flag = nofs_flag;

fs/smb/client/cifsglob.h

852

static inline void cifs_server_unlock(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

854

unsigned int nofs_flag = server->nofs_flag;

fs/smb/client/cifsglob.h

856

mutex_unlock(&server->_srv_mutex);

fs/smb/client/cifsglob.h

869

in_flight(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

873

spin_lock(&server->req_lock);

fs/smb/client/cifsglob.h

874

num = server->in_flight;

fs/smb/client/cifsglob.h

875

spin_unlock(&server->req_lock);

fs/smb/client/cifsglob.h

880

has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)

fs/smb/client/cifsglob.h

884

spin_lock(&server->req_lock);

fs/smb/client/cifsglob.h

886

spin_unlock(&server->req_lock);

fs/smb/client/cifsglob.h

891

add_credits(struct TCP_Server_Info *server, struct cifs_credits *credits,

fs/smb/client/cifsglob.h

894

server->ops->add_credits(server, credits, optype);

fs/smb/client/cifsglob.h

898

add_credits_and_wake_if(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

902

server->ops->add_credits(server, credits, optype);

fs/smb/client/cifsglob.h

903

wake_up(&server->request_q);

fs/smb/client/cifsglob.h

909

set_credits(struct TCP_Server_Info *server, const int val)

fs/smb/client/cifsglob.h

911

server->ops->set_credits(server, val);

fs/smb/client/cifsglob.h

915

adjust_credits(struct TCP_Server_Info *server, struct cifs_io_subrequest *subreq,

fs/smb/client/cifsglob.h

918

return server->ops->adjust_credits ?

fs/smb/client/cifsglob.h

919

server->ops->adjust_credits(server, subreq, trace) : 0;

fs/smb/client/cifsglob.h

923

get_next_mid64(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

925

return cpu_to_le64(server->ops->get_next_mid(server));

fs/smb/client/cifsglob.h

929

get_next_mid(struct TCP_Server_Info *server)

fs/smb/client/cifsglob.h

931

__u16 mid = server->ops->get_next_mid(server);

fs/smb/client/cifsglob.h

940

revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)

fs/smb/client/cifsglob.h

942

if (server->ops->revert_current_mid)

fs/smb/client/cifsglob.h

943

server->ops->revert_current_mid(server, val);

fs/smb/client/cifsglob.h

947

revert_current_mid_from_hdr(struct TCP_Server_Info *server,

fs/smb/client/cifsglob.h

952

return revert_current_mid(server, num > 0 ? num : 1);

fs/smb/client/cifsproto.h

102

struct TCP_Server_Info *server, struct smb_rqst *rqst,

fs/smb/client/cifsproto.h

105

struct TCP_Server_Info *server, const int flags,

fs/smb/client/cifsproto.h

109

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

110

int __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,

fs/smb/client/cifsproto.h

112

int wait_for_free_request(struct TCP_Server_Info *server, const int flags,

fs/smb/client/cifsproto.h

114

int cifs_wait_mtu_credits(struct TCP_Server_Info *server, size_t size,

fs/smb/client/cifsproto.h

118

send_cancel(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

122

return server->ops->send_cancel ?

fs/smb/client/cifsproto.h

123

server->ops->send_cancel(ses, server, rqst, mid, xid) : 0;

fs/smb/client/cifsproto.h

126

int wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *mid);

fs/smb/client/cifsproto.h

129

void cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

131

void cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

133

int cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session);

fs/smb/client/cifsproto.h

154

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

225

void dequeue_mid(struct TCP_Server_Info *server, struct mid_q_entry *mid,

fs/smb/client/cifsproto.h

227

int cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,

fs/smb/client/cifsproto.h

229

ssize_t cifs_discard_from_socket(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

231

int cifs_read_iter_from_socket(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

275

void cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect);

fs/smb/client/cifsproto.h

290

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

292

struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

294

int cifs_enable_signing(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

310

void cifs_crypto_secmech_release(struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

313

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

315

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

333

struct cifs_ses *cifs_get_smb_ses(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

336

int cifs_readv_receive(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

34

int smb_send_kvec(struct TCP_Server_Info *server, struct msghdr *smb_msg,

fs/smb/client/cifsproto.h

348

struct TCP_Server_Info *server, char *signature,

fs/smb/client/cifsproto.h

350

enum securityEnum cifs_select_sectype(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

358

struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

363

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

365

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

367

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

369

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

371

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

373

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

375

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

379

struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

416

int match_target_ip(struct TCP_Server_Info *server, const char *host,

fs/smb/client/cifsproto.h

442

int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry);

fs/smb/client/cifsproto.h

482

static inline void release_mid(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/cifsproto.h

485

__release_mid(server, mid);

fs/smb/client/cifsproto.h

83

void delete_mid(struct TCP_Server_Info *server, struct mid_q_entry *mid);

fs/smb/client/cifsproto.h

84

void __release_mid(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

86

void cifs_wake_up_task(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

88

int cifs_handle_standard(struct TCP_Server_Info *server,

fs/smb/client/cifsproto.h

95

int cifs_discard_remaining_data(struct TCP_Server_Info *server);

fs/smb/client/cifsproto.h

96

int cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,

fs/smb/client/cifssmb.c

105

rc = cifs_wait_for_server_reconnect(server, tcon->retry);

fs/smb/client/cifssmb.c

110

if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {

fs/smb/client/cifssmb.c

121

spin_lock(&server->srv_lock);

fs/smb/client/cifssmb.c

122

switch (server->tcpStatus) {

fs/smb/client/cifssmb.c

124

spin_unlock(&server->srv_lock);

fs/smb/client/cifssmb.c

128

spin_unlock(&server->srv_lock);

fs/smb/client/cifssmb.c

136

spin_unlock(&server->srv_lock);

fs/smb/client/cifssmb.c

144

if (!cifs_chan_needs_reconnect(ses, server) &&

fs/smb/client/cifssmb.c

1463

cifs_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/cifssmb.c

1487

if (server->sign) {

fs/smb/client/cifssmb.c

1491

rc = cifs_verify_signature(&rqst, server,

fs/smb/client/cifssmb.c

1509

if (server->sign && rdata->got_bytes)

fs/smb/client/cifssmb.c

1559

server->credits, server->in_flight,

fs/smb/client/cifssmb.c

1566

release_mid(server, mid);

fs/smb/client/cifssmb.c

1567

add_credits(server, &credits, 0);

fs/smb/client/cifssmb.c

1569

server->credits, server->in_flight,

fs/smb/client/cifssmb.c

159

rc = cifs_negotiate_protocol(0, ses, server);

fs/smb/client/cifssmb.c

1634

rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,

fs/smb/client/cifssmb.c

166

rc = cifs_setup_session(0, ses, server, ses->local_nls);

fs/smb/client/cifssmb.c

1683

if (tcon->ses->server == NULL)

fs/smb/client/cifssmb.c

1798

if (tcon->ses->server == NULL)

fs/smb/client/cifssmb.c

1818

bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)

fs/smb/client/cifssmb.c

1883

cifs_writev_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/cifssmb.c

1899

result = cifs_check_receive(mid, tcon->ses->server, 0);

fs/smb/client/cifssmb.c

1946

server->credits, server->in_flight,

fs/smb/client/cifssmb.c

1950

release_mid(server, mid);

fs/smb/client/cifssmb.c

1952

server->credits, server->in_flight,

fs/smb/client/cifssmb.c

1954

add_credits(tcon->ses->server, &credits, 0);

fs/smb/client/cifssmb.c

2025

rc = cifs_call_async(tcon->ses->server, &rqst, NULL,

fs/smb/client/cifssmb.c

2035

add_credits_and_wake_if(wdata->server, &wdata->credits, 0);

fs/smb/client/cifssmb.c

2079

if (tcon->ses->server == NULL)

fs/smb/client/cifssmb.c

264

buffer->Mid = get_next_mid(ses->server);

fs/smb/client/cifssmb.c

325

if (cifs_chan_needs_reconnect(tcon->ses, tcon->ses->server) ||

fs/smb/client/cifssmb.c

373

struct TCP_Server_Info *server = ses->server;

fs/smb/client/cifssmb.c

381

if (server->srv_count > 1) {

fs/smb/client/cifssmb.c

383

if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {

fs/smb/client/cifssmb.c

385

memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);

fs/smb/client/cifssmb.c

389

memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);

fs/smb/client/cifssmb.c

393

server->sec_ntlmssp = true;

fs/smb/client/cifssmb.c

397

pSMBr->u.extended_response.SecurityBlob, count, server);

fs/smb/client/cifssmb.c

425

struct TCP_Server_Info *server)

fs/smb/client/cifssmb.c

435

if (!server) {

fs/smb/client/cifssmb.c

446

pSMB->hdr.Mid = get_next_mid(server);

fs/smb/client/cifssmb.c

476

server->dialect = le16_to_cpu(pSMBr->DialectIndex);

fs/smb/client/cifssmb.c

477

cifs_dbg(FYI, "Dialect: %d\n", server->dialect);

fs/smb/client/cifssmb.c

479

if ((pSMBr->hdr.WordCount <= 13) || (server->dialect == BAD_PROT)) {

fs/smb/client/cifssmb.c

4812

pSMB->hdr.Mid = get_next_mid(ses->server);

fs/smb/client/cifssmb.c

4832

if (ses->server->sign)

fs/smb/client/cifssmb.c

492

server->sec_mode = pSMBr->SecurityMode;

fs/smb/client/cifssmb.c

493

if ((server->sec_mode & SECMODE_USER) == 0)

fs/smb/client/cifssmb.c

498

server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),

fs/smb/client/cifssmb.c

500

set_credits(server, server->maxReq);

fs/smb/client/cifssmb.c

502

server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);

fs/smb/client/cifssmb.c

504

server->max_read = server->maxBuf;

fs/smb/client/cifssmb.c

505

server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);

fs/smb/client/cifssmb.c

506

cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);

fs/smb/client/cifssmb.c

507

server->capabilities = le32_to_cpu(pSMBr->Capabilities);

fs/smb/client/cifssmb.c

508

server->session_key_id = pSMBr->SessionKey;

fs/smb/client/cifssmb.c

509

server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);

fs/smb/client/cifssmb.c

510

server->timeAdj *= 60;

fs/smb/client/cifssmb.c

513

server->negflavor = CIFS_NEGFLAVOR_UNENCAP;

fs/smb/client/cifssmb.c

514

memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,

fs/smb/client/cifssmb.c

517

server->capabilities & CAP_EXTENDED_SECURITY) {

fs/smb/client/cifssmb.c

518

server->negflavor = CIFS_NEGFLAVOR_EXTENDED;

fs/smb/client/cifssmb.c

520

} else if (server->sec_mode & SECMODE_PW_ENCRYPT) {

fs/smb/client/cifssmb.c

524

server->negflavor = CIFS_NEGFLAVOR_UNENCAP;

fs/smb/client/cifssmb.c

525

server->capabilities &= ~CAP_EXTENDED_SECURITY;

fs/smb/client/cifssmb.c

529

rc = cifs_enable_signing(server, ses->sign);

fs/smb/client/cifssmb.c

566

smb_buffer->Mid = get_next_mid(ses->server);

fs/smb/client/cifssmb.c

580

if (ses->server->sign)

fs/smb/client/cifssmb.c

687

if ((tcon->ses == NULL) || (tcon->ses->server == NULL))

fs/smb/client/cifssmb.c

730

cifs_echo_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/cifssmb.c

734

release_mid(server, mid);

fs/smb/client/cifssmb.c

735

add_credits(server, &credits, CIFS_ECHO_OP);

fs/smb/client/cifssmb.c

739

CIFSSMBEcho(struct TCP_Server_Info *server)

fs/smb/client/cifssmb.c

74

struct TCP_Server_Info *server;

fs/smb/client/cifssmb.c

757

if (server->capabilities & CAP_UNICODE)

fs/smb/client/cifssmb.c

771

rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback, NULL,

fs/smb/client/cifssmb.c

772

server, CIFS_NON_BLOCKING | CIFS_ECHO_OP, NULL);

fs/smb/client/cifssmb.c

795

if (!ses || !ses->server)

fs/smb/client/cifssmb.c

814

pSMB->hdr.Mid = get_next_mid(ses->server);

fs/smb/client/cifssmb.c

816

if (ses->server->sign)

fs/smb/client/cifssmb.c

87

server = ses->server;

fs/smb/client/compress.c

283

if (unlikely(!tcon || !tcon->ses || !tcon->ses->server))

fs/smb/client/compress.c

286

if (!tcon->ses->server->compression.enabled)

fs/smb/client/compress.c

304

int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq, compress_send_fn send_fn)

fs/smb/client/compress.c

311

if (!server || !rq || !rq->rq_iov || !rq->rq_iov->iov_base)

fs/smb/client/compress.c

363

ret = send_fn(server, 1, &comp_rq);

fs/smb/client/compress.c

365

ret = send_fn(server, 1, rq);

fs/smb/client/compress.h

33

int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq,

fs/smb/client/connect.c

1001

mid->large_buf = server->large_buf;

fs/smb/client/connect.c

1005

if (server->large_buf)

fs/smb/client/connect.c

1006

server->bigbuf = NULL;

fs/smb/client/connect.c

1008

server->smallbuf = NULL;

fs/smb/client/connect.c

1010

dequeue_mid(server, mid, malformed);

fs/smb/client/connect.c

1014

cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)

fs/smb/client/connect.c

1016

bool srv_sign_required = server->sec_mode & server->vals->signing_required;

fs/smb/client/connect.c

1017

bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;

fs/smb/client/connect.c

1041

server->sign = true;

fs/smb/client/connect.c

1050

server->sign = true;

fs/smb/client/connect.c

1053

if (cifs_rdma_enabled(server) && server->sign)

fs/smb/client/connect.c

1060

clean_demultiplex_info(struct TCP_Server_Info *server)

fs/smb/client/connect.c

1065

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

1066

list_del_init(&server->tcp_ses_list);

fs/smb/client/connect.c

1067

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

1069

cancel_delayed_work_sync(&server->echo);

fs/smb/client/connect.c

1071

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

1072

server->tcpStatus = CifsExiting;

fs/smb/client/connect.c

1073

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

1074

wake_up_all(&server->response_q);

fs/smb/client/connect.c

1077

spin_lock(&server->req_lock);

fs/smb/client/connect.c

1078

if (server->credits <= 0)

fs/smb/client/connect.c

1079

server->credits = 1;

fs/smb/client/connect.c

1080

spin_unlock(&server->req_lock);

fs/smb/client/connect.c

1088

wake_up_all(&server->request_q);

fs/smb/client/connect.c

1091

if (cifs_rdma_enabled(server))

fs/smb/client/connect.c

1092

smbd_destroy(server);

fs/smb/client/connect.c

1093

if (server->ssocket) {

fs/smb/client/connect.c

1094

sock_release(server->ssocket);

fs/smb/client/connect.c

1095

server->ssocket = NULL;

fs/smb/client/connect.c

1098

if (!list_empty(&server->pending_mid_q)) {

fs/smb/client/connect.c

110

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/connect.c

1103

spin_lock(&server->mid_queue_lock);

fs/smb/client/connect.c

1104

list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {

fs/smb/client/connect.c

1112

spin_unlock(&server->mid_queue_lock);

fs/smb/client/connect.c

1119

mid_execute_callback(server, mid_entry);

fs/smb/client/connect.c

1120

release_mid(server, mid_entry);

fs/smb/client/connect.c

1126

if (!list_empty(&server->pending_mid_q)) {

fs/smb/client/connect.c

1143

put_net(cifs_net_ns(server));

fs/smb/client/connect.c

1144

kfree(server->leaf_fullpath);

fs/smb/client/connect.c

1145

kfree(server->hostname);

fs/smb/client/connect.c

1146

kfree(server);

fs/smb/client/connect.c

115

if (!server->ops->query_server_interfaces)

fs/smb/client/connect.c

1154

standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/connect.c

1157

char *buf = server->smallbuf;

fs/smb/client/connect.c

1158

unsigned int pdu_length = server->pdu_size;

fs/smb/client/connect.c

1161

if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {

fs/smb/client/connect.c

1163

cifs_reconnect(server, true);

fs/smb/client/connect.c

1169

server->large_buf = true;

fs/smb/client/connect.c

1170

memcpy(server->bigbuf, buf, server->total_read);

fs/smb/client/connect.c

1171

buf = server->bigbuf;

fs/smb/client/connect.c

1175

length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,

fs/smb/client/connect.c

1176

pdu_length - MID_HEADER_SIZE(server));

fs/smb/client/connect.c

1180

server->total_read += length;

fs/smb/client/connect.c

1182

dump_smb(buf, server->total_read);

fs/smb/client/connect.c

1184

return cifs_handle_standard(server, mid);

fs/smb/client/connect.c

1188

cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/connect.c

119

rc = server->ops->query_server_interfaces(xid, tcon, false);

fs/smb/client/connect.c

1190

char *buf = server->large_buf ? server->bigbuf : server->smallbuf;

fs/smb/client/connect.c

1201

rc = server->ops->check_message(buf, server->pdu_size,

fs/smb/client/connect.c

1202

server->total_read, server);

fs/smb/client/connect.c

1205

min_t(unsigned int, server->total_read, 48));

fs/smb/client/connect.c

1207

if (server->ops->is_session_expired &&

fs/smb/client/connect.c

1208

server->ops->is_session_expired(buf)) {

fs/smb/client/connect.c

1209

cifs_reconnect(server, true);

fs/smb/client/connect.c

1213

if (server->ops->is_status_pending &&

fs/smb/client/connect.c

1214

server->ops->is_status_pending(buf, server))

fs/smb/client/connect.c

1220

handle_mid(mid, server, buf, rc);

fs/smb/client/connect.c

1225

smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)

fs/smb/client/connect.c

1233

if (is_smb1(server))

fs/smb/client/connect.c

1237

spin_lock(&server->req_lock);

fs/smb/client/connect.c

1238

server->credits += le16_to_cpu(shdr->CreditRequest);

fs/smb/client/connect.c

1239

scredits = server->credits;

fs/smb/client/connect.c

1240

in_flight = server->in_flight;

fs/smb/client/connect.c

1241

spin_unlock(&server->req_lock);

fs/smb/client/connect.c

1242

wake_up(&server->request_q);

fs/smb/client/connect.c

1244

trace_smb3_hdr_credits(server->current_mid,

fs/smb/client/connect.c

1245

server->conn_id, server->hostname, scredits,

fs/smb/client/connect.c

1258

struct TCP_Server_Info *server = p;

fs/smb/client/connect.c

1277

while (server->tcpStatus != CifsExiting) {

fs/smb/client/connect.c

1281

if (!allocate_buffers(server))

fs/smb/client/connect.c

1284

server->large_buf = false;

fs/smb/client/connect.c

1285

buf = server->smallbuf;

fs/smb/client/connect.c

1288

length = cifs_read_from_socket(server, buf, pdu_length);

fs/smb/client/connect.c

1292

server->total_read = 0;

fs/smb/client/connect.c

130

#define set_need_reco(server) \

fs/smb/client/connect.c

1301

if (!is_smb_response(server, buf[0]))

fs/smb/client/connect.c

1306

server->pdu_size = pdu_length;

fs/smb/client/connect.c

1309

if (server->pdu_size < MID_HEADER_SIZE(server)) {

fs/smb/client/connect.c

1311

server->pdu_size);

fs/smb/client/connect.c

1312

cifs_reconnect(server, true);

fs/smb/client/connect.c

1317

length = cifs_read_from_socket(server, buf,

fs/smb/client/connect.c

1318

MID_HEADER_SIZE(server));

fs/smb/client/connect.c

132

spin_lock(&server->srv_lock); \

fs/smb/client/connect.c

1321

server->total_read += length;

fs/smb/client/connect.c

1323

if (server->ops->next_header) {

fs/smb/client/connect.c

1324

if (server->ops->next_header(server, buf, &next_offset)) {

fs/smb/client/connect.c

1327

cifs_reconnect(server, true);

fs/smb/client/connect.c

133

if (server->tcpStatus != CifsExiting) \

fs/smb/client/connect.c

1331

server->pdu_size = next_offset;

fs/smb/client/connect.c

1338

if (server->ops->is_transform_hdr &&

fs/smb/client/connect.c

1339

server->ops->receive_transform &&

fs/smb/client/connect.c

134

server->tcpStatus = CifsNeedReconnect; \

fs/smb/client/connect.c

1340

server->ops->is_transform_hdr(buf)) {

fs/smb/client/connect.c

1341

length = server->ops->receive_transform(server,

fs/smb/client/connect.c

1346

mids[0] = server->ops->find_mid(server, buf);

fs/smb/client/connect.c

135

spin_unlock(&server->srv_lock); \

fs/smb/client/connect.c

1353

length = standard_receive3(server, mids[0]);

fs/smb/client/connect.c

1355

length = mids[0]->receive(server, mids[0]);

fs/smb/client/connect.c

1361

release_mid(server, mids[i]);

fs/smb/client/connect.c

1365

if (server->ops->is_status_io_timeout &&

fs/smb/client/connect.c

1366

server->ops->is_status_io_timeout(buf)) {

fs/smb/client/connect.c

1378

server->lstrp = jiffies;

fs/smb/client/connect.c

1382

mids[i]->resp_buf_size = server->pdu_size;

fs/smb/client/connect.c

1385

if (server->ops->is_network_name_deleted &&

fs/smb/client/connect.c

1386

server->ops->is_network_name_deleted(bufs[i],

fs/smb/client/connect.c

1387

server)) {

fs/smb/client/connect.c

1394

mid_execute_callback(server, mids[i]);

fs/smb/client/connect.c

1396

release_mid(server, mids[i]);

fs/smb/client/connect.c

1397

} else if (server->ops->is_oplock_break &&

fs/smb/client/connect.c

1398

server->ops->is_oplock_break(bufs[i],

fs/smb/client/connect.c

1399

server)) {

fs/smb/client/connect.c

1400

smb2_add_credits_from_hdr(bufs[i], server);

fs/smb/client/connect.c

1406

HEADER_SIZE(server));

fs/smb/client/connect.c

1407

smb2_add_credits_from_hdr(bufs[i], server);

fs/smb/client/connect.c

1409

if (server->ops->dump_detail)

fs/smb/client/connect.c

1410

server->ops->dump_detail(bufs[i], pdu_length,

fs/smb/client/connect.c

1411

server);

fs/smb/client/connect.c

1412

cifs_dump_mids(server);

fs/smb/client/connect.c

1417

if (pdu_length > server->pdu_size) {

fs/smb/client/connect.c

1418

if (!allocate_buffers(server))

fs/smb/client/connect.c

1420

pdu_length -= server->pdu_size;

fs/smb/client/connect.c

1421

server->total_read = 0;

fs/smb/client/connect.c

1422

server->large_buf = false;

fs/smb/client/connect.c

1423

buf = server->smallbuf;

fs/smb/client/connect.c

1429

cifs_reconnect(server, true);

fs/smb/client/connect.c

1434

cifs_buf_release(server->bigbuf);

fs/smb/client/connect.c

1435

if (server->smallbuf) /* no sense logging a debug message if NULL */

fs/smb/client/connect.c

1436

cifs_small_buf_release(server->smallbuf);

fs/smb/client/connect.c

1438

task_to_wake = xchg(&server->tsk, NULL);

fs/smb/client/connect.c

1439

clean_demultiplex_info(server);

fs/smb/client/connect.c

148

cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info *server,

fs/smb/client/connect.c

1540

match_port(struct TCP_Server_Info *server, struct sockaddr *addr)

fs/smb/client/connect.c

1545

if (server->rdma)

fs/smb/client/connect.c

1550

sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;

fs/smb/client/connect.c

1554

sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;

fs/smb/client/connect.c

1573

static bool match_server_address(struct TCP_Server_Info *server, struct sockaddr *addr)

fs/smb/client/connect.c

1575

if (!cifs_match_ipaddr(addr, (struct sockaddr *)&server->dstaddr))

fs/smb/client/connect.c

158

set_need_reco(server);

fs/smb/client/connect.c

1582

match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)

fs/smb/client/connect.c

1589

if (server->ops->select_sectype(server, ctx->sectype)

fs/smb/client/connect.c

1598

if (ctx->sign && !server->sign)

fs/smb/client/connect.c

1605

static int match_server(struct TCP_Server_Info *server,

fs/smb/client/connect.c

1611

lockdep_assert_held(&server->srv_lock);

fs/smb/client/connect.c

1617

if (server->nosharesock)

fs/smb/client/connect.c

162

if (SERVER_IS_CHAN(server))

fs/smb/client/connect.c

1620

if (!match_super && (ctx->dfs_conn || server->dfs_conn))

fs/smb/client/connect.c

1625

if (server->vals->protocol_id < SMB30_PROT_ID)

fs/smb/client/connect.c

1629

if (server->vals->protocol_id < SMB21_PROT_ID)

fs/smb/client/connect.c

163

server = server->primary_server;

fs/smb/client/connect.c

1631

} else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))

fs/smb/client/connect.c

1634

if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))

fs/smb/client/connect.c

1638

(struct sockaddr *)&server->srcaddr))

fs/smb/client/connect.c

1641

if (strcasecmp(server->hostname, ctx->server_hostname) ||

fs/smb/client/connect.c

1642

!match_server_address(server, addr) ||

fs/smb/client/connect.c

1643

!match_port(server, addr))

fs/smb/client/connect.c

1646

if (!match_security(server, ctx))

fs/smb/client/connect.c

1649

if (server->echo_interval != ctx->echo_interval * HZ)

fs/smb/client/connect.c

165

set_need_reco(server);

fs/smb/client/connect.c

1652

if (server->rdma != ctx->rdma)

fs/smb/client/connect.c

1655

if (server->ignore_signature != ctx->ignore_signature)

fs/smb/client/connect.c

1658

if (server->min_offload != ctx->min_offload)

fs/smb/client/connect.c

166

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/connect.c

1661

if (server->retrans != ctx->retrans)

fs/smb/client/connect.c

1670

struct TCP_Server_Info *server;

fs/smb/client/connect.c

1673

list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

fs/smb/client/connect.c

1674

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

1679

if (SERVER_IS_CHAN(server) ||

fs/smb/client/connect.c

1680

!match_server(server, ctx, false)) {

fs/smb/client/connect.c

1681

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

1684

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

1686

++server->srv_count;

fs/smb/client/connect.c

1689

return server;

fs/smb/client/connect.c

1696

cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)

fs/smb/client/connect.c

1701

if (--server->srv_count > 0) {

fs/smb/client/connect.c

1707

WARN_ON(server->srv_count < 0);

fs/smb/client/connect.c

1709

list_del_init(&server->tcp_ses_list);

fs/smb/client/connect.c

1712

cancel_delayed_work_sync(&server->echo);

fs/smb/client/connect.c

1721

cancel_delayed_work(&server->reconnect);

fs/smb/client/connect.c

1723

cancel_delayed_work_sync(&server->reconnect);

fs/smb/client/connect.c

1726

if (SERVER_IS_CHAN(server))

fs/smb/client/connect.c

1727

cifs_put_tcp_session(server->primary_server, from_reconnect);

fs/smb/client/connect.c

1729

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

1730

server->tcpStatus = CifsExiting;

fs/smb/client/connect.c

1731

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

1733

cifs_crypto_secmech_release(server);

fs/smb/client/connect.c

1735

kfree_sensitive(server->session_key.response);

fs/smb/client/connect.c

1736

server->session_key.response = NULL;

fs/smb/client/connect.c

1737

server->session_key.len = 0;

fs/smb/client/connect.c

1739

task = xchg(&server->tsk, NULL);

fs/smb/client/connect.c

174

nserver = ses->chans[i].server;

fs/smb/client/connect.c

185

list_for_each_entry_safe(server, nserver, &reco, rlist) {

fs/smb/client/connect.c

186

list_del_init(&server->rlist);

fs/smb/client/connect.c

187

set_need_reco(server);

fs/smb/client/connect.c

188

cifs_put_tcp_session(server, 0);

fs/smb/client/connect.c

1934

struct TCP_Server_Info *server = ses->server;

fs/smb/client/connect.c

1947

ctx_sec = server->ops->select_sectype(server, ctx->sectype);

fs/smb/client/connect.c

1948

ses_sec = server->ops->select_sectype(server, ses->sectype);

fs/smb/client/connect.c

2029

struct TCP_Server_Info *server = ses->server;

fs/smb/client/connect.c

203

cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info *server,

fs/smb/client/connect.c

2035

if (seal && !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)) {

fs/smb/client/connect.c

2045

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

2046

scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);

fs/smb/client/connect.c

2047

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

2053

rc = server->ops->tree_connect(xid, ses, unc, tcon, ses->local_nls);

fs/smb/client/connect.c

2071

cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)

fs/smb/client/connect.c

2076

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/connect.c

2100

struct TCP_Server_Info *server = ses->server;

fs/smb/client/connect.c

2121

cifs_chan_clear_need_reconnect(ses, server);

fs/smb/client/connect.c

2124

do_logoff = ses->ses_status == SES_GOOD && server->ops->logoff;

fs/smb/client/connect.c

2142

rc = server->ops->logoff(xid, ses);

fs/smb/client/connect.c

2158

cifs_put_tcp_session(ses->chans[i].server, 0);

fs/smb/client/connect.c

2159

ses->chans[i].server = NULL;

fs/smb/client/connect.c

2165

ses->chans[0].server = NULL;

fs/smb/client/connect.c

2169

cifs_put_tcp_session(server, 0);

fs/smb/client/connect.c

217

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/connect.c

2185

struct TCP_Server_Info *server = ses->server;

fs/smb/client/connect.c

2197

switch (server->dstaddr.ss_family) {

fs/smb/client/connect.c

2199

sa = (struct sockaddr_in *)&server->dstaddr;

fs/smb/client/connect.c

2203

sa6 = (struct sockaddr_in6 *)&server->dstaddr;

fs/smb/client/connect.c

2208

server->dstaddr.ss_family);

fs/smb/client/connect.c

227

if (server->terminate) {

fs/smb/client/connect.c

229

server = pserver;

fs/smb/client/connect.c

2336

cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)

fs/smb/client/connect.c

2338

struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;

fs/smb/client/connect.c

2339

struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;

fs/smb/client/connect.c

2349

ses = cifs_find_smb_ses(server, ctx);

fs/smb/client/connect.c

2355

if (cifs_chan_needs_reconnect(ses, server)) {

fs/smb/client/connect.c

2362

rc = cifs_negotiate_protocol(xid, ses, server);

fs/smb/client/connect.c

2371

rc = cifs_setup_session(xid, ses, server,

fs/smb/client/connect.c

2394

cifs_put_tcp_session(server, 0);

fs/smb/client/connect.c

2407

ses->server = server;

fs/smb/client/connect.c

2408

if (server->dstaddr.ss_family == AF_INET6)

fs/smb/client/connect.c

242

if (cifs_ses_get_chan_index(ses, server) ==

fs/smb/client/connect.c

2479

ses->chans[0].server = server;

fs/smb/client/connect.c

248

if (!cifs_chan_is_iface_active(ses, server)) {

fs/smb/client/connect.c

2487

rc = cifs_negotiate_protocol(xid, ses, server);

fs/smb/client/connect.c

2489

rc = cifs_setup_session(xid, ses, server, ctx->local_nls);

fs/smb/client/connect.c

250

cifs_chan_update_iface(ses, server);

fs/smb/client/connect.c

2516

list_add(&ses->smb_ses_list, &server->smb_ses_list);

fs/smb/client/connect.c

2539

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/connect.c

254

if (!mark_smb_session && cifs_chan_needs_reconnect(ses, server)) {

fs/smb/client/connect.c

2549

} else if (!server->leaf_fullpath &&

fs/smb/client/connect.c

262

cifs_chan_set_need_reconnect(ses, server);

fs/smb/client/connect.c

2642

if (ses->server->ops->tree_disconnect)

fs/smb/client/connect.c

2643

ses->server->ops->tree_disconnect(xid, tcon);

fs/smb/client/connect.c

2694

if (!ses->server->ops->tree_connect) {

fs/smb/client/connect.c

2699

if (ses->server->dialect >= SMB20_PROT_ID &&

fs/smb/client/connect.c

2700

(ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING))

fs/smb/client/connect.c

2712

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2722

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2741

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2746

} else if (tcon->ses->server->capabilities &

fs/smb/client/connect.c

2757

if (ses->server->posix_ext_supported) {

fs/smb/client/connect.c

2760

} else if ((ses->server->vals->protocol_id == SMB311_PROT_ID) ||

fs/smb/client/connect.c

2761

(strcmp(ses->server->vals->version_string,

fs/smb/client/connect.c

2763

(strcmp(ses->server->vals->version_string,

fs/smb/client/connect.c

2768

} else if (ses->server->vals->protocol_id == SMB10_PROT_ID)

fs/smb/client/connect.c

2784

rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,

fs/smb/client/connect.c

2794

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2799

} else if (ses->server->capabilities &

fs/smb/client/connect.c

2809

&& (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)

fs/smb/client/connect.c

2814

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2825

if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {

fs/smb/client/connect.c

2860

if (ses->server->vals->protocol_id == 0) {

fs/smb/client/connect.c

2882

if (ses->server->dialect >= SMB30_PROT_ID &&

fs/smb/client/connect.c

2883

(ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {

fs/smb/client/connect.c

297

cifs_abort_connection(struct TCP_Server_Info *server)

fs/smb/client/connect.c

302

server->maxBuf = 0;

fs/smb/client/connect.c

3024

tcp_srv = ses->server;

fs/smb/client/connect.c

303

server->max_read = 0;

fs/smb/client/connect.c

307

cifs_server_lock(server);

fs/smb/client/connect.c

308

if (server->ssocket) {

fs/smb/client/connect.c

309

cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,

fs/smb/client/connect.c

310

server->ssocket->flags);

fs/smb/client/connect.c

3102

bind_socket(struct TCP_Server_Info *server)

fs/smb/client/connect.c

3106

if (server->srcaddr.ss_family != AF_UNSPEC) {

fs/smb/client/connect.c

3108

struct socket *socket = server->ssocket;

fs/smb/client/connect.c

311

kernel_sock_shutdown(server->ssocket, SHUT_WR);

fs/smb/client/connect.c

3111

(struct sockaddr_unsized *) &server->srcaddr,

fs/smb/client/connect.c

3112

sizeof(server->srcaddr));

fs/smb/client/connect.c

3117

saddr4 = (struct sockaddr_in *)&server->srcaddr;

fs/smb/client/connect.c

3118

saddr6 = (struct sockaddr_in6 *)&server->srcaddr;

fs/smb/client/connect.c

312

cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", server->ssocket->state,

fs/smb/client/connect.c

313

server->ssocket->flags);

fs/smb/client/connect.c

3131

smb_recv_kvec(struct TCP_Server_Info *server, struct msghdr *msg, size_t *recv)

fs/smb/client/connect.c

3135

int msg_flags = server->noblocksnd ? MSG_DONTWAIT : 0;

fs/smb/client/connect.c

314

sock_release(server->ssocket);

fs/smb/client/connect.c

3140

rc = sock_recvmsg(server->ssocket, msg, msg_flags);

fs/smb/client/connect.c

3144

(!server->noblocksnd && (retries > 2))) {

fs/smb/client/connect.c

3146

server->ssocket);

fs/smb/client/connect.c

315

server->ssocket = NULL;

fs/smb/client/connect.c

316

} else if (cifs_rdma_enabled(server)) {

fs/smb/client/connect.c

3169

ip_rfc1001_connect(struct TCP_Server_Info *server)

fs/smb/client/connect.c

317

smbd_destroy(server);

fs/smb/client/connect.c

3187

if (server->server_RFC1001_name[0] != 0)

fs/smb/client/connect.c

3189

server->server_RFC1001_name,

fs/smb/client/connect.c

319

server->sequence_number = 0;

fs/smb/client/connect.c

3199

if (server->workstation_RFC1001_name[0] != 0)

fs/smb/client/connect.c

320

server->session_estab = false;

fs/smb/client/connect.c

3201

server->workstation_RFC1001_name,

fs/smb/client/connect.c

321

kfree_sensitive(server->session_key.response);

fs/smb/client/connect.c

322

server->session_key.response = NULL;

fs/smb/client/connect.c

3220

rc = smb_send_kvec(server, &msg, &sent);

fs/smb/client/connect.c

323

server->session_key.len = 0;

fs/smb/client/connect.c

324

server->lstrp = jiffies;

fs/smb/client/connect.c

3240

rc = smb_recv_kvec(server, &msg, &recv);

fs/smb/client/connect.c

3260

smb_recv_kvec(server, &msg, &recv) == 0 &&

fs/smb/client/connect.c

3272

server->server_RFC1001_name[0] ?

fs/smb/client/connect.c

3273

server->server_RFC1001_name :

fs/smb/client/connect.c

3281

server->workstation_RFC1001_name[0] ?

fs/smb/client/connect.c

3282

server->workstation_RFC1001_name :

fs/smb/client/connect.c

329

spin_lock(&server->mid_queue_lock);

fs/smb/client/connect.c

330

list_for_each_entry_safe(mid, nmid, &server->pending_mid_q, qhead) {

fs/smb/client/connect.c

3309

if (smb_recv_kvec(server, &msg, &recv) == 0 && recv == len) {

fs/smb/client/connect.c

3324

server->with_rfc1001 = true;

fs/smb/client/connect.c

3329

generic_ip_connect(struct TCP_Server_Info *server)

fs/smb/client/connect.c

3337

saddr = (struct sockaddr *) &server->dstaddr;

fs/smb/client/connect.c

3339

if (server->dstaddr.ss_family == AF_INET6) {

fs/smb/client/connect.c

3340

struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;

fs/smb/client/connect.c

3348

struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;

fs/smb/client/connect.c

3357

if (server->ssocket) {

fs/smb/client/connect.c

3358

socket = server->ssocket;

fs/smb/client/connect.c

3360

struct net *net = cifs_net_ns(server);

fs/smb/client/connect.c

3364

IPPROTO_TCP, &server->ssocket);

fs/smb/client/connect.c

337

spin_unlock(&server->mid_queue_lock);

fs/smb/client/connect.c

3370

sk = server->ssocket->sk;

fs/smb/client/connect.c

3375

socket = server->ssocket;

fs/smb/client/connect.c

338

cifs_server_unlock(server);

fs/smb/client/connect.c

3384

rc = bind_socket(server);

fs/smb/client/connect.c

3397

if (server->noautotune) {

fs/smb/client/connect.c

3404

if (server->tcp_nodelay)

fs/smb/client/connect.c

3412

server->noblockcnt ? O_NONBLOCK : 0);

fs/smb/client/connect.c

3418

if (server->noblockcnt && rc == -EINPROGRESS)

fs/smb/client/connect.c

3422

trace_smb3_connect_err(server->hostname, server->conn_id, &server->dstaddr, rc);

fs/smb/client/connect.c

3424

server->ssocket = NULL;

fs/smb/client/connect.c

3427

trace_smb3_connect_done(server->hostname, server->conn_id, &server->dstaddr);

fs/smb/client/connect.c

343

mid_execute_callback(server, mid);

fs/smb/client/connect.c

3435

if (server->with_rfc1001 ||

fs/smb/client/connect.c

3436

server->rfc1001_sessinit == 1 ||

fs/smb/client/connect.c

3437

(server->rfc1001_sessinit == -1 && sport == htons(RFC1001_PORT)))

fs/smb/client/connect.c

3438

rc = ip_rfc1001_connect(server);

fs/smb/client/connect.c

344

release_mid(server, mid);

fs/smb/client/connect.c

3444

ip_connect(struct TCP_Server_Info *server)

fs/smb/client/connect.c

3447

struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;

fs/smb/client/connect.c

3448

struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;

fs/smb/client/connect.c

3450

if (server->dstaddr.ss_family == AF_INET6)

fs/smb/client/connect.c

3461

rc = generic_ip_connect(server);

fs/smb/client/connect.c

3469

return generic_ip_connect(server);

fs/smb/client/connect.c

348

static bool cifs_tcp_ses_needs_reconnect(struct TCP_Server_Info *server, int num_targets)

fs/smb/client/connect.c

350

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

351

server->nr_targets = num_targets;

fs/smb/client/connect.c

352

if (server->tcpStatus == CifsExiting) {

fs/smb/client/connect.c

3538

else if (mnt_ctx->server)

fs/smb/client/connect.c

3539

cifs_put_tcp_session(mnt_ctx->server, 0);

fs/smb/client/connect.c

354

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

3542

mnt_ctx->server = NULL;

fs/smb/client/connect.c

3549

struct TCP_Server_Info *server = NULL;

fs/smb/client/connect.c

355

wake_up(&server->response_q);

fs/smb/client/connect.c

3564

server = cifs_get_tcp_session(ctx, NULL);

fs/smb/client/connect.c

3565

if (IS_ERR(server)) {

fs/smb/client/connect.c

3566

rc = PTR_ERR(server);

fs/smb/client/connect.c

3567

server = NULL;

fs/smb/client/connect.c

3572

ses = cifs_get_smb_ses(server, ctx);

fs/smb/client/connect.c

3579

if ((ctx->persistent == true) && (!(ses->server->capabilities &

fs/smb/client/connect.c

3587

mnt_ctx->server = server;

fs/smb/client/connect.c

3596

struct TCP_Server_Info *server;

fs/smb/client/connect.c

360

trace_smb3_reconnect(server->current_mid, server->conn_id,

fs/smb/client/connect.c

3605

if (WARN_ON_ONCE(!mnt_ctx->server || !mnt_ctx->ses ||

fs/smb/client/connect.c

361

server->hostname);

fs/smb/client/connect.c

3610

server = mnt_ctx->server;

fs/smb/client/connect.c

362

server->tcpStatus = CifsNeedReconnect;

fs/smb/client/connect.c

364

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

3641

spin_lock(&tcon->ses->server->srv_lock);

fs/smb/client/connect.c

3642

if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&

fs/smb/client/connect.c

3645

spin_unlock(&tcon->ses->server->srv_lock);

fs/smb/client/connect.c

3649

spin_unlock(&tcon->ses->server->srv_lock);

fs/smb/client/connect.c

3655

if (!tcon->pipe && server->ops->qfs_tcon) {

fs/smb/client/connect.c

3656

server->ops->qfs_tcon(mnt_ctx->xid, tcon, cifs_sb);

fs/smb/client/connect.c

3667

cifs_negotiate_iosize(server, cifs_sb->ctx, tcon);

fs/smb/client/connect.c

3713

cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,

fs/smb/client/connect.c

3728

rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");

fs/smb/client/connect.c

3752

rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,

fs/smb/client/connect.c

3768

struct TCP_Server_Info *server = mnt_ctx->server;

fs/smb/client/connect.c

3774

if (!server->ops->is_path_accessible)

fs/smb/client/connect.c

3787

rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,

fs/smb/client/connect.c

3793

rc = cifs_are_all_path_components_accessible(server, xid, tcon,

fs/smb/client/connect.c

381

static int __cifs_reconnect(struct TCP_Server_Info *server,

fs/smb/client/connect.c

3840

mchan_mount->ses->server,

fs/smb/client/connect.c

386

if (!cifs_tcp_ses_needs_reconnect(server, 1))

fs/smb/client/connect.c

3917

if (WARN_ON(!mnt_ctx.server))

fs/smb/client/connect.c

394

cifs_signal_cifsd_for_reconnect(server, mark_smb_session);

fs/smb/client/connect.c

396

cifs_mark_tcp_ses_conns_for_reconnect(server, mark_smb_session);

fs/smb/client/connect.c

398

cifs_abort_connection(server);

fs/smb/client/connect.c

4006

struct TCP_Server_Info *server)

fs/smb/client/connect.c

4011

if (!server->ops->need_neg || !server->ops->negotiate)

fs/smb/client/connect.c

4016

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

4017

if (server->tcpStatus != CifsGood &&

fs/smb/client/connect.c

4018

server->tcpStatus != CifsNew &&

fs/smb/client/connect.c

4019

server->tcpStatus != CifsNeedNegotiate) {

fs/smb/client/connect.c

402

cifs_server_lock(server);

fs/smb/client/connect.c

4020

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

4024

if (!server->ops->need_neg(server) &&

fs/smb/client/connect.c

4025

server->tcpStatus == CifsGood) {

fs/smb/client/connect.c

4026

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

4030

server->tcpStatus = CifsInNegotiate;

fs/smb/client/connect.c

4031

server->neg_start = jiffies;

fs/smb/client/connect.c

4032

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

4034

rc = server->ops->negotiate(xid, ses, server);

fs/smb/client/connect.c

404

if (!cifs_swn_set_server_dstaddr(server) &&

fs/smb/client/connect.c

4044

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

4045

if (server->tcpStatus == CifsInNegotiate)

fs/smb/client/connect.c

4046

server->tcpStatus = CifsGood;

fs/smb/client/connect.c

4049

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

405

!SERVER_IS_CHAN(server)) {

fs/smb/client/connect.c

4051

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

4052

if (server->tcpStatus == CifsInNegotiate)

fs/smb/client/connect.c

4053

server->tcpStatus = CifsNeedNegotiate;

fs/smb/client/connect.c

4054

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

4062

struct TCP_Server_Info *server,

fs/smb/client/connect.c

4066

struct TCP_Server_Info *pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/connect.c

407

rc = reconn_set_ipaddr_from_hostname(server);

fs/smb/client/connect.c

4094

cifs_chan_set_in_reconnect(ses, server);

fs/smb/client/connect.c

4109

if (server == pserver) {

fs/smb/client/connect.c

411

if (cifs_rdma_enabled(server))

fs/smb/client/connect.c

4110

if (server->dstaddr.ss_family == AF_INET6)

fs/smb/client/connect.c

4117

ses->capabilities = server->capabilities;

fs/smb/client/connect.c

4119

ses->capabilities &= (~server->vals->cap_unix);

fs/smb/client/connect.c

412

rc = smbd_reconnect(server);

fs/smb/client/connect.c

4126

if (ses->unicode == 1 && server->vals->cap_unicode != 0 &&

fs/smb/client/connect.c

4127

!(server->capabilities & server->vals->cap_unicode)) {

fs/smb/client/connect.c

4130

} else if (ses->unicode == 0 && server->vals->cap_unicode == 0) {

fs/smb/client/connect.c

4138

ses->capabilities &= (~server->vals->cap_unicode);

fs/smb/client/connect.c

414

rc = generic_ip_connect(server);

fs/smb/client/connect.c

4151

server->sec_mode, server->capabilities, server->timeAdj);

fs/smb/client/connect.c

4154

if (server->ops->sess_setup)

fs/smb/client/connect.c

4155

rc = server->ops->sess_setup(xid, ses, server, nls_info);

fs/smb/client/connect.c

416

cifs_server_unlock(server);

fs/smb/client/connect.c

4169

cifs_chan_clear_in_reconnect(ses, server);

fs/smb/client/connect.c

4177

cifs_chan_clear_in_reconnect(ses, server);

fs/smb/client/connect.c

4178

cifs_chan_clear_need_reconnect(ses, server);

fs/smb/client/connect.c

424

set_credits(server, 1);

fs/smb/client/connect.c

4241

++master_tcon->ses->server->srv_count;

fs/smb/client/connect.c

4244

ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);

fs/smb/client/connect.c

4247

cifs_put_tcp_session(master_tcon->ses->server, 0);

fs/smb/client/connect.c

425

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

426

if (server->tcpStatus != CifsExiting)

fs/smb/client/connect.c

427

server->tcpStatus = CifsNeedNegotiate;

fs/smb/client/connect.c

428

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

429

cifs_swn_reset_server_dstaddr(server);

fs/smb/client/connect.c

430

cifs_server_unlock(server);

fs/smb/client/connect.c

431

cifs_queue_server_reconn(server);

fs/smb/client/connect.c

433

} while (server->tcpStatus == CifsNeedReconnect);

fs/smb/client/connect.c

435

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

436

if (server->tcpStatus == CifsNeedNegotiate)

fs/smb/client/connect.c

437

mod_delayed_work(cifsiod_wq, &server->echo, 0);

fs/smb/client/connect.c

438

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

440

wake_up(&server->response_q);

fs/smb/client/connect.c

445

static int __reconnect_target_locked(struct TCP_Server_Info *server,

fs/smb/client/connect.c

4492

const struct smb_version_operations *ops = tcon->ses->server->ops;

fs/smb/client/connect.c

451

if (!cifs_swn_set_server_dstaddr(server)) {

fs/smb/client/connect.c

452

if (server->hostname != target) {

fs/smb/client/connect.c

455

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

456

kfree(server->hostname);

fs/smb/client/connect.c

457

server->hostname = hostname;

fs/smb/client/connect.c

458

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

463

server->hostname);

fs/smb/client/connect.c

467

rc = reconn_set_ipaddr_from_hostname(server);

fs/smb/client/connect.c

471

if (cifs_rdma_enabled(server))

fs/smb/client/connect.c

472

rc = smbd_reconnect(server);

fs/smb/client/connect.c

474

rc = generic_ip_connect(server);

fs/smb/client/connect.c

479

static int reconnect_target_locked(struct TCP_Server_Info *server,

fs/smb/client/connect.c

491

return __reconnect_target_locked(server, server->hostname);

fs/smb/client/connect.c

497

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

498

if (server->tcpStatus != CifsNeedReconnect) {

fs/smb/client/connect.c

499

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

502

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

503

rc = __reconnect_target_locked(server, target);

fs/smb/client/connect.c

512

static int reconnect_dfs_server(struct TCP_Server_Info *server)

fs/smb/client/connect.c

515

const char *ref_path = server->leaf_fullpath + 1;

fs/smb/client/connect.c

533

if (!cifs_tcp_ses_needs_reconnect(server, num_targets))

fs/smb/client/connect.c

541

cifs_mark_tcp_ses_conns_for_reconnect(server, true);

fs/smb/client/connect.c

543

cifs_abort_connection(server);

fs/smb/client/connect.c

547

cifs_server_lock(server);

fs/smb/client/connect.c

549

rc = reconnect_target_locked(server, &tl, &target_hint);

fs/smb/client/connect.c

552

cifs_server_unlock(server);

fs/smb/client/connect.c

563

set_credits(server, 1);

fs/smb/client/connect.c

564

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

565

if (server->tcpStatus != CifsExiting)

fs/smb/client/connect.c

566

server->tcpStatus = CifsNeedNegotiate;

fs/smb/client/connect.c

567

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

568

cifs_swn_reset_server_dstaddr(server);

fs/smb/client/connect.c

569

cifs_server_unlock(server);

fs/smb/client/connect.c

570

cifs_queue_server_reconn(server);

fs/smb/client/connect.c

571

} while (server->tcpStatus == CifsNeedReconnect);

fs/smb/client/connect.c

577

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

578

if (server->tcpStatus == CifsNeedNegotiate)

fs/smb/client/connect.c

579

mod_delayed_work(cifsiod_wq, &server->echo, 0);

fs/smb/client/connect.c

580

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

582

wake_up(&server->response_q);

fs/smb/client/connect.c

587

_cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session, bool once)

fs/smb/client/connect.c

589

if (!server->leaf_fullpath)

fs/smb/client/connect.c

590

return __cifs_reconnect(server, mark_smb_session, once);

fs/smb/client/connect.c

591

return reconnect_dfs_server(server);

fs/smb/client/connect.c

595

_cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session, bool once)

fs/smb/client/connect.c

597

return __cifs_reconnect(server, mark_smb_session, once);

fs/smb/client/connect.c

602

cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session)

fs/smb/client/connect.c

604

return _cifs_reconnect(server, mark_smb_session, false);

fs/smb/client/connect.c

608

cifs_reconnect_once(struct TCP_Server_Info *server)

fs/smb/client/connect.c

61

static int ip_connect(struct TCP_Server_Info *server);

fs/smb/client/connect.c

610

return _cifs_reconnect(server, true, true);

fs/smb/client/connect.c

617

struct TCP_Server_Info *server = container_of(work,

fs/smb/client/connect.c

62

static int generic_ip_connect(struct TCP_Server_Info *server);

fs/smb/client/connect.c

625

if (server->tcpStatus == CifsNeedReconnect ||

fs/smb/client/connect.c

626

server->tcpStatus == CifsExiting ||

fs/smb/client/connect.c

627

server->tcpStatus == CifsNew ||

fs/smb/client/connect.c

628

(server->ops->can_echo && !server->ops->can_echo(server)) ||

fs/smb/client/connect.c

629

time_before(jiffies, server->lstrp + server->echo_interval - HZ))

fs/smb/client/connect.c

632

rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;

fs/smb/client/connect.c

639

queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);

fs/smb/client/connect.c

643

allocate_buffers(struct TCP_Server_Info *server)

fs/smb/client/connect.c

645

if (!server->bigbuf) {

fs/smb/client/connect.c

646

server->bigbuf = (char *)cifs_buf_get();

fs/smb/client/connect.c

647

if (!server->bigbuf) {

fs/smb/client/connect.c

653

} else if (server->large_buf) {

fs/smb/client/connect.c

655

memset(server->bigbuf, 0, HEADER_SIZE(server));

fs/smb/client/connect.c

658

if (!server->smallbuf) {

fs/smb/client/connect.c

659

server->smallbuf = (char *)cifs_small_buf_get();

fs/smb/client/connect.c

660

if (!server->smallbuf) {

fs/smb/client/connect.c

669

memset(server->smallbuf, 0, HEADER_SIZE(server));

fs/smb/client/connect.c

676

server_unresponsive(struct TCP_Server_Info *server)

fs/smb/client/connect.c

684

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

685

if (server->tcpStatus == CifsInNegotiate &&

fs/smb/client/connect.c

686

time_after(jiffies, server->neg_start + 20 * HZ)) {

fs/smb/client/connect.c

687

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

688

cifs_reconnect(server, false);

fs/smb/client/connect.c

702

if ((server->tcpStatus == CifsGood ||

fs/smb/client/connect.c

703

server->tcpStatus == CifsNeedNegotiate) &&

fs/smb/client/connect.c

704

(!server->ops->can_echo || server->ops->can_echo(server)) &&

fs/smb/client/connect.c

705

time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {

fs/smb/client/connect.c

706

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

708

(3 * server->echo_interval) / HZ);

fs/smb/client/connect.c

709

cifs_reconnect(server, false);

fs/smb/client/connect.c

712

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

718

zero_credits(struct TCP_Server_Info *server)

fs/smb/client/connect.c

722

spin_lock(&server->req_lock);

fs/smb/client/connect.c

723

val = server->credits + server->echo_credits + server->oplock_credits;

fs/smb/client/connect.c

724

if (server->in_flight == 0 && val == 0) {

fs/smb/client/connect.c

725

spin_unlock(&server->req_lock);

fs/smb/client/connect.c

728

spin_unlock(&server->req_lock);

fs/smb/client/connect.c

733

cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)

fs/smb/client/connect.c

742

if (zero_credits(server)) {

fs/smb/client/connect.c

743

cifs_reconnect(server, false);

fs/smb/client/connect.c

747

if (server_unresponsive(server))

fs/smb/client/connect.c

749

if (cifs_rdma_enabled(server) && server->smbd_conn)

fs/smb/client/connect.c

750

length = smbd_recv(server->smbd_conn, smb_msg);

fs/smb/client/connect.c

752

length = sock_recvmsg(server->ssocket, smb_msg, 0);

fs/smb/client/connect.c

754

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

755

if (server->tcpStatus == CifsExiting) {

fs/smb/client/connect.c

756

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

76

static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)

fs/smb/client/connect.c

760

if (server->tcpStatus == CifsNeedReconnect) {

fs/smb/client/connect.c

761

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

762

cifs_reconnect(server, false);

fs/smb/client/connect.c

765

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

782

cifs_reconnect(server, false);

fs/smb/client/connect.c

790

cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,

fs/smb/client/connect.c

798

return cifs_readv_from_socket(server, &smb_msg);

fs/smb/client/connect.c

802

cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)

fs/smb/client/connect.c

81

if (!server->hostname)

fs/smb/client/connect.c

813

return cifs_readv_from_socket(server, &smb_msg);

fs/smb/client/connect.c

817

cifs_read_iter_from_socket(struct TCP_Server_Info *server, struct iov_iter *iter,

fs/smb/client/connect.c

823

return cifs_readv_from_socket(server, &smb_msg);

fs/smb/client/connect.c

827

is_smb_response(struct TCP_Server_Info *server, unsigned char type)

fs/smb/client/connect.c

85

if (server->hostname[0] == '\0')

fs/smb/client/connect.c

854

cifs_reconnect(server, true);

fs/smb/client/connect.c

869

if (!cifs_rdma_enabled(server) &&

fs/smb/client/connect.c

870

server->tcpStatus == CifsInNegotiate &&

fs/smb/client/connect.c

871

!server->with_rfc1001 &&

fs/smb/client/connect.c

872

server->rfc1001_sessinit != 0) {

fs/smb/client/connect.c

88

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

886

spin_lock(&server->mid_queue_lock);

fs/smb/client/connect.c

887

list_for_each_entry_safe(mid, nmid, &server->pending_mid_q, qhead) {

fs/smb/client/connect.c

89

ss = server->dstaddr;

fs/smb/client/connect.c

892

spin_unlock(&server->mid_queue_lock);

fs/smb/client/connect.c

895

server->with_rfc1001 = true;

fs/smb/client/connect.c

896

rc = cifs_reconnect_once(server);

fs/smb/client/connect.c

90

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

92

rc = dns_resolve_name(server->dns_dom, server->hostname,

fs/smb/client/connect.c

921

mid_execute_callback(server, mid);

fs/smb/client/connect.c

922

release_mid(server, mid);

fs/smb/client/connect.c

93

strlen(server->hostname),

fs/smb/client/connect.c

938

cifs_reconnect(server, true);

fs/smb/client/connect.c

943

cifs_reconnect(server, true);

fs/smb/client/connect.c

947

cifs_reconnect(server, true);

fs/smb/client/connect.c

954

dequeue_mid(struct TCP_Server_Info *server, struct mid_q_entry *mid, bool malformed)

fs/smb/client/connect.c

959

spin_lock(&server->mid_queue_lock);

fs/smb/client/connect.c

96

spin_lock(&server->srv_lock);

fs/smb/client/connect.c

969

spin_unlock(&server->mid_queue_lock);

fs/smb/client/connect.c

97

memcpy(&server->dstaddr, &ss, sizeof(server->dstaddr));

fs/smb/client/connect.c

974

spin_unlock(&server->mid_queue_lock);

fs/smb/client/connect.c

979

smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)

fs/smb/client/connect.c

98

spin_unlock(&server->srv_lock);

fs/smb/client/connect.c

986

if (is_smb1(server))

fs/smb/client/connect.c

993

handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/connect.c

996

if (server->ops->check_trans2 &&

fs/smb/client/connect.c

997

server->ops->check_trans2(mid, server, buf, malformed))

fs/smb/client/connect.c

999

mid->credits_received = smb2_get_credits_from_hdr(buf, server);

fs/smb/client/dfs.c

220

if (WARN_ON(!mnt_ctx->server))

fs/smb/client/dfs.c

312

static int target_share_matches_server(struct TCP_Server_Info *server, char *share,

fs/smb/client/dfs.c

323

cifs_server_lock(server);

fs/smb/client/dfs.c

324

if (dfs_host_len != strlen(server->hostname) ||

fs/smb/client/dfs.c

325

strncasecmp(dfs_host, server->hostname, dfs_host_len)) {

fs/smb/client/dfs.c

327

(int)dfs_host_len, dfs_host, server->hostname);

fs/smb/client/dfs.c

328

rc = match_target_ip(server, dfs_host, dfs_host_len, target_match);

fs/smb/client/dfs.c

332

cifs_server_unlock(server);

fs/smb/client/dfs.c

342

const struct smb_version_operations *ops = tcon->ses->server->ops;

fs/smb/client/dfs.c

343

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/dfs.c

357

rc = dfs_cache_get_tgt_share(server->leaf_fullpath + 1, tit, &share, &prefix);

fs/smb/client/dfs.c

363

rc = target_share_matches_server(server, share, &target_match);

fs/smb/client/dfs.c

371

dfs_cache_noreq_update_tgthint(server->leaf_fullpath + 1, tit);

fs/smb/client/dfs.c

389

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/dfs.c

390

const struct smb_version_operations *ops = server->ops;

fs/smb/client/dfs.c

425

cifs_server_lock(server);

fs/smb/client/dfs.c

426

scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);

fs/smb/client/dfs.c

427

cifs_server_unlock(server);

fs/smb/client/dfs.c

438

if (!server->leaf_fullpath ||

fs/smb/client/dfs.c

439

dfs_cache_noreq_find(server->leaf_fullpath + 1, &ref, &tl)) {

fs/smb/client/dfs.h

194

const char *path = ses->server->leaf_fullpath;

fs/smb/client/dfs_cache.c

1098

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/dfs_cache.c

1111

rc = dns_resolve_unc(server->dns_dom, s1, (struct sockaddr *)&ss);

fs/smb/client/dfs_cache.c

1115

cifs_server_lock(server);

fs/smb/client/dfs_cache.c

1116

match = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, (struct sockaddr *)&ss);

fs/smb/client/dfs_cache.c

1118

cifs_server_unlock(server);

fs/smb/client/dfs_cache.c

1125

struct TCP_Server_Info *server = ses->server;

fs/smb/client/dfs_cache.c

1133

ret = !cifs_chan_needs_reconnect(ses, server) &&

fs/smb/client/dfs_cache.c

1168

if (ipc && server->ops->tree_disconnect) {

fs/smb/client/dfs_cache.c

1171

(void)server->ops->tree_disconnect(xid, ipc);

fs/smb/client/dfs_cache.c

1248

cifs_signal_cifsd_for_reconnect(tcon->ses->server, true);

fs/smb/client/dfs_cache.c

653

if (!ses || !ses->server || !ses->server->ops->get_dfs_refer)

fs/smb/client/dfs_cache.c

659

rc = ses->server->ops->get_dfs_refer(xid, ses, path, refs, numrefs, cache_cp,

fs/smb/client/dir.c

192

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/dir.c

199

if (tcon->ses->server->oplocks)

fs/smb/client/dir.c

306

if (!server->ops->open) {

fs/smb/client/dir.c

321

if (tcon->cfids && direntry->d_parent && server->dialect >= SMB30_PROT_ID) {

fs/smb/client/dir.c

353

rc = server->ops->open(xid, &oparms, oplock, buf);

fs/smb/client/dir.c

414

if (server->ops->set_lease_key)

fs/smb/client/dir.c

415

server->ops->set_lease_key(newinode, fid);

fs/smb/client/dir.c

453

if (server->ops->close)

fs/smb/client/dir.c

454

server->ops->close(xid, tcon, fid);

fs/smb/client/dir.c

466

struct TCP_Server_Info *server;

fs/smb/client/dir.c

519

server = tcon->ses->server;

fs/smb/client/dir.c

521

if (server->ops->new_lease_key)

fs/smb/client/dir.c

522

server->ops->new_lease_key(&fid);

fs/smb/client/dir.c

538

if (server->ops->close)

fs/smb/client/dir.c

539

server->ops->close(xid, tcon, &fid);

fs/smb/client/dir.c

554

if (server->ops->close)

fs/smb/client/dir.c

555

server->ops->close(xid, tcon, &fid);

fs/smb/client/dir.c

587

struct TCP_Server_Info *server;

fs/smb/client/dir.c

606

server = tcon->ses->server;

fs/smb/client/dir.c

608

if (server->ops->new_lease_key)

fs/smb/client/dir.c

609

server->ops->new_lease_key(&fid);

fs/smb/client/dir.c

612

if (!rc && server->ops->close)

fs/smb/client/dir.c

613

server->ops->close(xid, tcon, &fid);

fs/smb/client/dir.c

656

rc = tcon->ses->server->ops->make_node(xid, inode, direntry, tcon,

fs/smb/client/file.c

100

if (server->smbd_conn) {

fs/smb/client/file.c

1009

struct TCP_Server_Info *server;

fs/smb/client/file.c

102

smbd_get_parameters(server->smbd_conn);

fs/smb/client/file.c

1035

server = tcon->ses->server;

fs/smb/client/file.c

1087

if (server->oplocks)

fs/smb/client/file.c

1119

if (server->ops->get_lease_key)

fs/smb/client/file.c

1120

server->ops->get_lease_key(inode, &fid);

fs/smb/client/file.c

1125

if (server->ops->get_lease_key)

fs/smb/client/file.c

1126

server->ops->get_lease_key(inode, &fid);

fs/smb/client/file.c

1138

if (server->ops->close)

fs/smb/client/file.c

1139

server->ops->close(xid, tcon, &fid);

fs/smb/client/file.c

1214

rc = tcon->ses->server->ops->push_mand_locks(cfile);

fs/smb/client/file.c

1228

struct TCP_Server_Info *server;

fs/smb/client/file.c

124

rc = adjust_credits(wdata->server, wdata, cifs_trace_rw_credits_issue_write_adjust);

fs/smb/client/file.c

1250

server = tcon->ses->server;

fs/smb/client/file.c

1270

if (tcon->ses->server->oplocks)

fs/smb/client/file.c

1309

if (server->ops->get_lease_key)

fs/smb/client/file.c

1310

server->ops->get_lease_key(inode, &cfile->fid);

fs/smb/client/file.c

132

wdata->server->ops->async_writev(wdata);

fs/smb/client/file.c

1331

rc = server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/file.c

1334

rc = server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/file.c

1388

if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {

fs/smb/client/file.c

1394

server->ops->set_fid(cfile, &cfile->fid, oplock);

fs/smb/client/file.c

141

add_credits_and_wake_if(wdata->server, &wdata->credits, 0);

fs/smb/client/file.c

1516

struct TCP_Server_Info *server;

fs/smb/client/file.c

1526

server = tcon->ses->server;

fs/smb/client/file.c

1530

if (server->ops->dir_needs_close(cfile)) {

fs/smb/client/file.c

1533

if (server->ops->close_dir)

fs/smb/client/file.c

1534

rc = server->ops->close_dir(xid, tcon, &cfile->fid);

fs/smb/client/file.c

159

struct TCP_Server_Info *server;

fs/smb/client/file.c

1601

struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;

fs/smb/client/file.c

1608

server->ops->compare_fids(cfile, cur_cfile)) {

fs/smb/client/file.c

1610

if (!(li->type & server->vals->shared_lock_type) ||

fs/smb/client/file.c

1614

if ((type & server->vals->shared_lock_type) &&

fs/smb/client/file.c

1615

((server->ops->compare_fids(cfile, cur_cfile) &&

fs/smb/client/file.c

1620

server->ops->compare_fids(cfile, cur_cfile))

fs/smb/client/file.c

1663

struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;

fs/smb/client/file.c

1675

if (conf_lock->type & server->vals->shared_lock_type)

fs/smb/client/file.c

169

server = cifs_pick_channel(tlink_tcon(req->cfile->tlink)->ses);

fs/smb/client/file.c

170

rdata->server = server;

fs/smb/client/file.c

173

cifs_negotiate_rsize(server, cifs_sb->ctx,

fs/smb/client/file.c

176

rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,

fs/smb/client/file.c

1824

max_buf = tcon->ses->server->maxBuf;

fs/smb/client/file.c

190

server->credits, server->in_flight, 0,

fs/smb/client/file.c

194

if (server->smbd_conn) {

fs/smb/client/file.c

196

smbd_get_parameters(server->smbd_conn);

fs/smb/client/file.c

2011

rc = tcon->ses->server->ops->push_mand_locks(cfile);

fs/smb/client/file.c

2020

bool *wait_flag, struct TCP_Server_Info *server)

fs/smb/client/file.c

2040

*type = server->vals->large_lock_type;

fs/smb/client/file.c

2043

*type |= server->vals->exclusive_lock_type;

fs/smb/client/file.c

2047

*type |= server->vals->unlock_lock_type;

fs/smb/client/file.c

2052

*type |= server->vals->shared_lock_type;

fs/smb/client/file.c

2056

*type |= server->vals->exclusive_lock_type;

fs/smb/client/file.c

2060

*type |= server->vals->shared_lock_type;

fs/smb/client/file.c

2074

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

2085

if (type & server->vals->shared_lock_type)

fs/smb/client/file.c

2102

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,

fs/smb/client/file.c

2105

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2114

if (type & server->vals->shared_lock_type) {

fs/smb/client/file.c

2119

type &= ~server->vals->exclusive_lock_type;

fs/smb/client/file.c

2121

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2122

type | server->vals->shared_lock_type,

fs/smb/client/file.c

2125

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2126

type | server->vals->shared_lock_type, 0, 1, false);

fs/smb/client/file.c

215

struct TCP_Server_Info *server = rdata->server;

fs/smb/client/file.c

2202

max_buf = tcon->ses->server->maxBuf;

fs/smb/client/file.c

222

rc = adjust_credits(server, rdata, cifs_trace_rw_credits_issue_read_adjust);

fs/smb/client/file.c

2301

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

2312

if (type & server->vals->shared_lock_type)

fs/smb/client/file.c

2358

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2367

rc = server->ops->mand_unlock_range(cfile, flock, xid);

fs/smb/client/file.c

239

rc = rdata->server->ops->async_readv(rdata);

fs/smb/client/file.c

2410

tcon->ses->server);

fs/smb/client/file.c

2459

tcon->ses->server);

fs/smb/client/file.c

2790

struct TCP_Server_Info *server;

fs/smb/client/file.c

2808

server = tcon->ses->server;

fs/smb/client/file.c

2809

if (server->ops->flush == NULL) {

fs/smb/client/file.c

2817

rc = server->ops->flush(xid, tcon, &smbfile->fid);

fs/smb/client/file.c

2822

rc = server->ops->flush(xid, tcon, &smbfile->fid);

fs/smb/client/file.c

2858

struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;

fs/smb/client/file.c

2878

server->vals->exclusive_lock_type, 0,

fs/smb/client/file.c

3035

tcon->ses->server->vals->shared_lock_type,

fs/smb/client/file.c

3048

tcon->ses->server->vals->shared_lock_type,

fs/smb/client/file.c

3162

struct TCP_Server_Info *server;

fs/smb/client/file.c

3177

server = tcon->ses->server;

fs/smb/client/file.c

3182

server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,

fs/smb/client/file.c

3244

rc = server->ops->oplock_response(tcon, persistent_fid,

fs/smb/client/file.c

336

rdata->server ? rdata->server->credits : 0,

fs/smb/client/file.c

337

rdata->server ? rdata->server->in_flight : 0,

fs/smb/client/file.c

340

if (rdata->server)

fs/smb/client/file.c

341

add_credits_and_wake_if(rdata->server, &rdata->credits, 0);

fs/smb/client/file.c

53

struct TCP_Server_Info *server;

fs/smb/client/file.c

549

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

553

if (!server->ops->open)

fs/smb/client/file.c

601

rc = server->ops->open(xid, &oparms, oplock, buf);

fs/smb/client/file.c

622

server->ops->close(xid, tcon, fid);

fs/smb/client/file.c

64

server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);

fs/smb/client/file.c

65

wdata->server = server;

fs/smb/client/file.c

667

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

68

cifs_negotiate_wsize(server, cifs_sb->ctx,

fs/smb/client/file.c

711

if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {

fs/smb/client/file.c

731

server->ops->set_fid(cfile, fid, oplock);

fs/smb/client/file.c

797

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

803

if (server->ops->close_getattr)

fs/smb/client/file.c

804

rc = server->ops->close_getattr(0, tcon, cifs_file);

fs/smb/client/file.c

805

else if (server->ops->close)

fs/smb/client/file.c

806

rc = server->ops->close(0, tcon, &cifs_file->fid);

fs/smb/client/file.c

82

rc = server->ops->wait_mtu_credits(server, wsize, &stream->sreq_max_len,

fs/smb/client/file.c

857

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

879

if (server->ops->get_lease_key)

fs/smb/client/file.c

880

server->ops->get_lease_key(inode, &fid);

fs/smb/client/file.c

910

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/file.c

915

if (server->ops->close_getattr)

fs/smb/client/file.c

916

rc = server->ops->close_getattr(xid, tcon, cifs_file);

fs/smb/client/file.c

917

else if (server->ops->close)

fs/smb/client/file.c

918

rc = server->ops->close(xid, tcon, &cifs_file->fid);

fs/smb/client/file.c

95

server->credits, server->in_flight,

fs/smb/client/file.c

956

return tcon->ses->server->ops->flush(xid, tcon,

fs/smb/client/file.c

962

rc = tcon->ses->server->ops->flush(xid, tcon, &cfile->fid);

fs/smb/client/file.c

975

struct TCP_Server_Info *server;

fs/smb/client/file.c

989

server = tcon->ses->server;

fs/smb/client/file.c

990

rc = server->ops->set_file_size(xid, tcon,

fs/smb/client/fs_context.c

1182

rc = smb3_update_ses_channels(ses, ses->server,

fs/smb/client/fs_context.h

399

static inline void cifs_negotiate_rsize(struct TCP_Server_Info *server,

fs/smb/client/fs_context.h

405

size = umax(server->ops->negotiate_rsize(tcon, ctx), PAGE_SIZE);

fs/smb/client/fs_context.h

411

static inline void cifs_negotiate_wsize(struct TCP_Server_Info *server,

fs/smb/client/fs_context.h

417

size = umax(server->ops->negotiate_wsize(tcon, ctx), PAGE_SIZE);

fs/smb/client/fs_context.h

423

static inline void cifs_negotiate_iosize(struct TCP_Server_Info *server,

fs/smb/client/fs_context.h

427

cifs_negotiate_rsize(server, ctx, tcon);

fs/smb/client/fs_context.h

428

cifs_negotiate_wsize(server, ctx, tcon);

fs/smb/client/fscache.c

38

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/fscache.c

40

const struct sockaddr *sa = (struct sockaddr *)&server->dstaddr;

fs/smb/client/inode.c

1078

tcon->ses->server->vals->cap_nt_find) == 0)

fs/smb/client/inode.c

1105

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/inode.c

1120

rc = server->ops->get_srv_inum(xid, *inode ? NULL : tcon, cifs_sb, full_path,

fs/smb/client/inode.c

1162

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/inode.c

1169

if (!tag && server->ops->query_reparse_point) {

fs/smb/client/inode.c

1170

rc = server->ops->query_reparse_point(xid, tcon, cifs_sb,

fs/smb/client/inode.c

1183

if (server->ops->query_symlink) {

fs/smb/client/inode.c

1184

rc = server->ops->query_symlink(xid, tcon,

fs/smb/client/inode.c

1206

} else if (iov && server->ops->get_reparse_point_buffer) {

fs/smb/client/inode.c

1210

reparse_buf = server->ops->get_reparse_point_buffer(iov, &reparse_len);

fs/smb/client/inode.c

1265

struct TCP_Server_Info *server;

fs/smb/client/inode.c

1276

server = tcon->ses->server;

fs/smb/client/inode.c

1283

rc = server->ops->query_path_info(xid, tcon, cifs_sb,

fs/smb/client/inode.c

1324

if (backup_cred(cifs_sb) && is_smb1_server(server)) {

fs/smb/client/inode.c

1453

struct TCP_Server_Info *server;

fs/smb/client/inode.c

1464

server = tcon->ses->server;

fs/smb/client/inode.c

1470

rc = server->ops->query_path_info(xid, tcon, cifs_sb,

fs/smb/client/inode.c

1736

struct TCP_Server_Info *server;

fs/smb/client/inode.c

1742

server = cifs_sb_master_tcon(cifs_sb)->ses->server;

fs/smb/client/inode.c

1743

if (!server->ops->set_file_info)

fs/smb/client/inode.c

1778

return server->ops->set_file_info(inode, full_path, &info_buf, xid);

fs/smb/client/inode.c

1945

struct TCP_Server_Info *server;

fs/smb/client/inode.c

1966

server = tcon->ses->server;

fs/smb/client/inode.c

1999

if (!server->ops->unlink) {

fs/smb/client/inode.c

2011

if (!sillyrename && server->vals->protocol_id > SMB10_PROT_ID) {

fs/smb/client/inode.c

2021

rc = server->ops->unlink(xid, tcon, full_path, cifs_sb, dentry);

fs/smb/client/inode.c

2033

if (server->ops->rename_pending_delete) {

fs/smb/client/inode.c

2034

rc = server->ops->rename_pending_delete(full_path,

fs/smb/client/inode.c

2168

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/inode.c

2170

(mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)

fs/smb/client/inode.c

2171

server->ops->mkdir_setinfo(inode, full_path, cifs_sb,

fs/smb/client/inode.c

2261

struct TCP_Server_Info *server;

fs/smb/client/inode.c

2285

server = tcon->ses->server;

fs/smb/client/inode.c

2287

if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {

fs/smb/client/inode.c

2288

rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,

fs/smb/client/inode.c

2304

if (!server->ops->mkdir) {

fs/smb/client/inode.c

2310

rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);

fs/smb/client/inode.c

2339

struct TCP_Server_Info *server;

fs/smb/client/inode.c

2366

server = tcon->ses->server;

fs/smb/client/inode.c

2368

if (!server->ops->rmdir) {

fs/smb/client/inode.c

2380

rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);

fs/smb/client/inode.c

2420

struct TCP_Server_Info *server;

fs/smb/client/inode.c

2432

server = tcon->ses->server;

fs/smb/client/inode.c

2434

if (!server->ops->rename) {

fs/smb/client/inode.c

2440

rc = server->ops->rename(xid, tcon, from_dentry,

fs/smb/client/inode.c

2452

if (server->vals->protocol_id != 0)

fs/smb/client/inode.c

2499

struct TCP_Server_Info *server;

fs/smb/client/inode.c

2535

server = tcon->ses->server;

fs/smb/client/inode.c

2649

server->vals->protocol_id > SMB10_PROT_ID);

fs/smb/client/inode.c

2974

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/inode.c

2998

if (server->ops->fiemap) {

fs/smb/client/inode.c

2999

rc = server->ops->fiemap(tcon, cfile, fei, start, len);

fs/smb/client/inode.c

3032

struct TCP_Server_Info *server;

fs/smb/client/inode.c

3046

server = tcon->ses->server;

fs/smb/client/inode.c

3047

rc = server->ops->set_file_size(xid, tcon,

fs/smb/client/inode.c

3055

server = tcon->ses->server;

fs/smb/client/inode.c

3056

rc = server->ops->set_file_size(xid, tcon,

fs/smb/client/inode.c

3072

server = tcon->ses->server;

fs/smb/client/inode.c

3080

rc = server->ops->set_path_size(xid, tcon, full_path, size,

fs/smb/client/inode.c

433

struct TCP_Server_Info *server;

fs/smb/client/inode.c

446

server = tcon->ses->server;

fs/smb/client/inode.c

473

if (!server->ops->query_symlink)

fs/smb/client/inode.c

475

rc = server->ops->query_symlink(xid, tcon,

fs/smb/client/inode.c

565

if (tcon->ses->server->oplocks)

fs/smb/client/inode.c

569

rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/inode.c

583

rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,

fs/smb/client/inode.c

646

rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,

fs/smb/client/inode.c

69

if (tcon->ses->server->max_read < PAGE_SIZE + MAX_CIFS_HDR_SIZE)

fs/smb/client/inode.c

692

tcon->ses->server->ops->close(xid, tcon, &fid);

fs/smb/client/inode.c

719

if (tcon->ses->server->ops->query_all_EAs == NULL) {

fs/smb/client/inode.c

724

rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,

fs/smb/client/inode.c

851

fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;

fs/smb/client/inode.c

852

fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;

fs/smb/client/inode.c

908

fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;

fs/smb/client/inode.c

909

fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;

fs/smb/client/inode.c

972

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/inode.c

977

if (!server->ops->query_file_info) {

fs/smb/client/inode.c

983

rc = server->ops->query_file_info(xid, tcon, cfile, &data);

fs/smb/client/ioctl.c

141

fsinf->protocol_id = tcon->ses->server->vals->protocol_id;

fs/smb/client/ioctl.c

291

switch (ses->server->cipher_type) {

fs/smb/client/ioctl.c

315

out.cipher_type = le16_to_cpu(ses->server->cipher_type);

fs/smb/client/ioctl.c

429

if (tcon->ses->server->ops->set_compression) {

fs/smb/client/ioctl.c

430

rc = tcon->ses->server->ops->set_compression(

fs/smb/client/ioctl.c

445

if (tcon->ses->server->ops->set_integrity)

fs/smb/client/ioctl.c

446

rc = tcon->ses->server->ops->set_integrity(xid,

fs/smb/client/ioctl.c

476

if (tcon->ses->server->ops->enum_snapshots)

fs/smb/client/ioctl.c

477

rc = tcon->ses->server->ops->enum_snapshots(xid, tcon,

fs/smb/client/ioctl.c

505

le16_to_cpu(tcon->ses->server->cipher_type);

fs/smb/client/ioctl.c

554

if (tcon && tcon->ses->server->ops->notify) {

fs/smb/client/ioctl.c

555

rc = tcon->ses->server->ops->notify(xid,

fs/smb/client/ioctl.c

56

if (tcon->ses->server->ops->ioctl_query_info)

fs/smb/client/ioctl.c

57

rc = tcon->ses->server->ops->ioctl_query_info(

fs/smb/client/ioctl.c

576

if (tcon && tcon->ses->server->ops->notify) {

fs/smb/client/ioctl.c

577

rc = tcon->ses->server->ops->notify(xid,

fs/smb/client/link.c

152

if (tcon->ses->server->ops->create_mf_symlink)

fs/smb/client/link.c

153

rc = tcon->ses->server->ops->create_mf_symlink(xid, tcon,

fs/smb/client/link.c

188

if (tcon->ses->server->ops->query_mf_symlink)

fs/smb/client/link.c

189

rc = tcon->ses->server->ops->query_mf_symlink(xid, tcon,

fs/smb/client/link.c

249

rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, &query_data);

fs/smb/client/link.c

292

rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/link.c

451

struct TCP_Server_Info *server;

fs/smb/client/link.c

486

server = tcon->ses->server;

fs/smb/client/link.c

487

if (!server->ops->create_hardlink) {

fs/smb/client/link.c

491

rc = server->ops->create_hardlink(xid, tcon, old_file,

fs/smb/client/misc.c

1020

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/misc.c

1037

spin_lock(&server->srv_lock);

fs/smb/client/misc.c

1038

if (!server->leaf_fullpath) {

fs/smb/client/misc.c

1039

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

1042

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

1072

if (ses->server->ops->get_dfs_refer &&

fs/smb/client/misc.c

1073

!ses->server->ops->get_dfs_refer(xid, ses, ref_path, &refs,

fs/smb/client/misc.c

1084

int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry)

fs/smb/client/misc.c

1089

spin_lock(&server->srv_lock);

fs/smb/client/misc.c

1090

if (server->tcpStatus != CifsNeedReconnect) {

fs/smb/client/misc.c

1091

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

1094

timeout *= server->nr_targets;

fs/smb/client/misc.c

1095

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

1106

rc = wait_event_interruptible_timeout(server->response_q,

fs/smb/client/misc.c

1107

(server->tcpStatus != CifsNeedReconnect),

fs/smb/client/misc.c

1116

spin_lock(&server->srv_lock);

fs/smb/client/misc.c

1117

if (server->tcpStatus != CifsNeedReconnect) {

fs/smb/client/misc.c

1118

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

1121

spin_unlock(&server->srv_lock);

fs/smb/client/misc.c

906

t1->ses->server == t2->ses->server &&

fs/smb/client/misc.c

963

int match_target_ip(struct TCP_Server_Info *server,

fs/smb/client/misc.c

974

rc = dns_resolve_name(server->dns_dom, host, hostlen,

fs/smb/client/misc.c

979

spin_lock(&server->srv_lock);

fs/smb/client/misc.c

980

*result = cifs_match_ipaddr((struct sockaddr *)&server->dstaddr, (struct sockaddr *)&ss);

fs/smb/client/misc.c

981

spin_unlock(&server->srv_lock);

fs/smb/client/ntlmssp.h

149

struct TCP_Server_Info *server,

fs/smb/client/ntlmssp.h

153

struct TCP_Server_Info *server,

fs/smb/client/ntlmssp.h

157

struct TCP_Server_Info *server,

fs/smb/client/readdir.c

1172

max_len = tcon->ses->server->ops->calc_smb_size(

fs/smb/client/readdir.c

328

int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj;

fs/smb/client/readdir.c

351

struct TCP_Server_Info *server;

fs/smb/client/readdir.c

377

server = tcon->ses->server;

fs/smb/client/readdir.c

379

if (!server->ops->query_dir_first) {

fs/smb/client/readdir.c

399

tcon->ses->server->vals->cap_nt_find) == 0) {

fs/smb/client/readdir.c

411

rc = server->ops->query_dir_first(xid, tcon, full_path, cifs_sb,

fs/smb/client/readdir.c

696

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/readdir.c

699

if (!server->ops->query_dir_first || !server->ops->query_dir_next)

fs/smb/client/readdir.c

723

if (server->ops->dir_needs_close(cfile)) {

fs/smb/client/readdir.c

726

if (server->ops->close_dir)

fs/smb/client/readdir.c

727

server->ops->close_dir(xid, tcon, &cfile->fid);

fs/smb/client/readdir.c

761

rc = server->ops->query_dir_next(xid, tcon, &cfile->fid,

fs/smb/client/readdir.c

783

server->ops->calc_smb_size(

fs/smb/client/reparse.c

231

new = tcon->ses->server->ops->create_reparse_inode(

fs/smb/client/reparse.c

335

open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/reparse.c

339

tcon->ses->server->ops->close(xid, tcon, &fid);

fs/smb/client/reparse.c

354

open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);

fs/smb/client/reparse.c

358

tcon->ses->server->ops->close(xid, tcon, &fid);

fs/smb/client/reparse.c

404

new = tcon->ses->server->ops->create_reparse_inode(

fs/smb/client/reparse.c

498

new = tcon->ses->server->ops->create_reparse_inode(

fs/smb/client/reparse.c

692

new = tcon->ses->server->ops->create_reparse_inode(

fs/smb/client/sess.c

1015

cifs_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)

fs/smb/client/sess.c

1017

switch (server->negflavor) {

fs/smb/client/sess.c

1025

if (server->sec_ntlmssp &&

fs/smb/client/sess.c

1028

if ((server->sec_kerberos || server->sec_mskerberos || server->sec_iakerb) &&

fs/smb/client/sess.c

108

struct TCP_Server_Info *server)

fs/smb/client/sess.c

110

unsigned int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

122

struct TCP_Server_Info *server)

fs/smb/client/sess.c

124

unsigned int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

134

struct TCP_Server_Info *server)

fs/smb/client/sess.c

136

unsigned int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

148

struct TCP_Server_Info *server = ses->server;

fs/smb/client/sess.c

170

if (server->dialect < SMB30_PROT_ID) {

fs/smb/client/sess.c

176

if (!(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {

fs/smb/client/sess.c

196

ses->server->hostname);

fs/smb/client/sess.c

210

if (iface->rdma_capable != ses->server->rdma)

fs/smb/client/sess.c

279

struct TCP_Server_Info *server;

fs/smb/client/sess.c

298

server = ses->chans[i].server;

fs/smb/client/sess.c

305

ses->chans[i].server = NULL;

fs/smb/client/sess.c

317

if (server) {

fs/smb/client/sess.c

318

if (!server->terminate) {

fs/smb/client/sess.c

319

server->terminate = true;

fs/smb/client/sess.c

320

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/sess.c

322

cifs_put_tcp_session(server, false);

fs/smb/client/sess.c

343

cifs_chan_update_iface(struct cifs_ses *ses, struct TCP_Server_Info *server)

fs/smb/client/sess.c

354

chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

369

spin_lock(&server->srv_lock);

fs/smb/client/sess.c

370

ss = server->dstaddr;

fs/smb/client/sess.c

371

spin_unlock(&server->srv_lock);

fs/smb/client/sess.c

376

cifs_dbg(ONCE, "server %s does not advertise interfaces\n", ses->server->hostname);

fs/smb/client/sess.c

398

if (iface->rdma_capable != server->rdma)

fs/smb/client/sess.c

465

chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

474

spin_lock(&server->srv_lock);

fs/smb/client/sess.c

475

memcpy(&server->dstaddr, &iface->sockaddr, sizeof(server->dstaddr));

fs/smb/client/sess.c

476

spin_unlock(&server->srv_lock);

fs/smb/client/sess.c

48

struct TCP_Server_Info *server)

fs/smb/client/sess.c

526

ctx->server_hostname = ses->server->hostname;

fs/smb/client/sess.c

53

if (server && server->terminate)

fs/smb/client/sess.c

546

ctx->vals = ses->server->vals;

fs/smb/client/sess.c

547

ctx->ops = ses->server->ops;

fs/smb/client/sess.c

549

ctx->noblocksnd = ses->server->noblocksnd;

fs/smb/client/sess.c

550

ctx->noautotune = ses->server->noautotune;

fs/smb/client/sess.c

551

ctx->sockopt_tcp_nodelay = ses->server->tcp_nodelay;

fs/smb/client/sess.c

552

ctx->echo_interval = ses->server->echo_interval / HZ;

fs/smb/client/sess.c

553

ctx->max_credits = ses->server->max_credits;

fs/smb/client/sess.c

554

ctx->min_offload = ses->server->min_offload;

fs/smb/client/sess.c

555

ctx->compress = ses->server->compression.requested;

fs/smb/client/sess.c

556

ctx->dfs_conn = ses->server->dfs_conn;

fs/smb/client/sess.c

557

ctx->ignore_signature = ses->server->ignore_signature;

fs/smb/client/sess.c

558

ctx->leaf_fullpath = ses->server->leaf_fullpath;

fs/smb/client/sess.c

559

ctx->rootfs = ses->server->noblockcnt;

fs/smb/client/sess.c

560

ctx->retrans = ses->server->retrans;

fs/smb/client/sess.c

57

if (ses->chans[i].server == server)

fs/smb/client/sess.c

573

memcpy(&ctx->client_guid, ses->server->client_guid,

fs/smb/client/sess.c

577

chan_server = cifs_get_tcp_session(ctx, ses->server);

fs/smb/client/sess.c

581

chan->server = chan_server;

fs/smb/client/sess.c

582

if (IS_ERR(chan->server)) {

fs/smb/client/sess.c

583

rc = PTR_ERR(chan->server);

fs/smb/client/sess.c

584

chan->server = NULL;

fs/smb/client/sess.c

593

cifs_chan_set_need_reconnect(ses, chan->server);

fs/smb/client/sess.c

603

rc = smb3_crypto_shash_allocate(chan->server);

fs/smb/client/sess.c

610

rc = cifs_negotiate_protocol(xid, ses, chan->server);

fs/smb/client/sess.c

612

rc = cifs_setup_session(xid, ses, chan->server, ses->local_nls);

fs/smb/client/sess.c

617

if (rc && chan->server) {

fs/smb/client/sess.c

618

cifs_put_tcp_session(chan->server, 0);

fs/smb/client/sess.c

62

if (server)

fs/smb/client/sess.c

623

cifs_chan_clear_need_reconnect(ses, chan->server);

fs/smb/client/sess.c

64

server->conn_id);

fs/smb/client/sess.c

680

if (ses->server->sign && !(server_flags & NTLMSSP_NEGOTIATE_SIGN)) {

fs/smb/client/sess.c

70

struct TCP_Server_Info *server)

fs/smb/client/sess.c

72

int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

784

struct TCP_Server_Info *server,

fs/smb/client/sess.c

813

if (!server->session_estab || ses->ntlmssp->sesskey_per_smbsess)

fs/smb/client/sess.c

82

struct TCP_Server_Info *server)

fs/smb/client/sess.c

84

unsigned int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

846

struct TCP_Server_Info *server,

fs/smb/client/sess.c

875

if (!server->session_estab || ses->ntlmssp->sesskey_per_smbsess)

fs/smb/client/sess.c

910

struct TCP_Server_Info *server,

fs/smb/client/sess.c

94

struct TCP_Server_Info *server)

fs/smb/client/sess.c

96

unsigned int chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/sess.c

995

(!ses->server->session_estab || ses->ntlmssp->sesskey_per_smbsess) &&

fs/smb/client/smb1debug.c

12

void cifs_dump_detail(void *buf, size_t buf_len, struct TCP_Server_Info *server)

fs/smb/client/smb1debug.c

20

if (!server->ops->check_message(buf, buf_len, server->total_read, server)) {

fs/smb/client/smb1debug.c

22

server->ops->calc_smb_size(smb));

fs/smb/client/smb1encrypt.c

125

cifs_server_lock(server);

fs/smb/client/smb1encrypt.c

126

rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);

fs/smb/client/smb1encrypt.c

127

cifs_server_unlock(server);

fs/smb/client/smb1encrypt.c

27

struct TCP_Server_Info *server, char *signature)

fs/smb/client/smb1encrypt.c

31

if (!rqst->rq_iov || !signature || !server)

fs/smb/client/smb1encrypt.c

40

md5_update(&ctx, server->session_key.response, server->session_key.len);

fs/smb/client/smb1encrypt.c

43

rqst, server, signature,

fs/smb/client/smb1encrypt.c

48

int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,

fs/smb/client/smb1encrypt.c

55

if ((cifs_pdu == NULL) || (server == NULL))

fs/smb/client/smb1encrypt.c

58

spin_lock(&server->srv_lock);

fs/smb/client/smb1encrypt.c

60

server->tcpStatus == CifsNeedNegotiate) {

fs/smb/client/smb1encrypt.c

61

spin_unlock(&server->srv_lock);

fs/smb/client/smb1encrypt.c

64

spin_unlock(&server->srv_lock);

fs/smb/client/smb1encrypt.c

66

if (!server->session_estab) {

fs/smb/client/smb1encrypt.c

72

cpu_to_le32(server->sequence_number);

fs/smb/client/smb1encrypt.c

75

*pexpected_response_sequence_number = ++server->sequence_number;

fs/smb/client/smb1encrypt.c

76

++server->sequence_number;

fs/smb/client/smb1encrypt.c

78

rc = cifs_calc_signature(rqst, server, smb_signature);

fs/smb/client/smb1encrypt.c

88

struct TCP_Server_Info *server,

fs/smb/client/smb1encrypt.c

96

if (cifs_pdu == NULL || server == NULL)

fs/smb/client/smb1encrypt.c

99

if (!server->session_estab)

fs/smb/client/smb1maperror.c

792

map_and_check_smb_error(struct TCP_Server_Info *server,

fs/smb/client/smb1maperror.c

808

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/smb1misc.c

48

if (treeCon->ses->server)

fs/smb/client/smb1misc.c

49

buffer->Mid = get_next_mid(treeCon->ses->server);

fs/smb/client/smb1misc.c

55

if ((treeCon->ses) && (treeCon->ses->server))

fs/smb/client/smb1misc.c

56

if (treeCon->ses->server->sign)

fs/smb/client/smb1ops.c

1277

cifs_can_echo(struct TCP_Server_Info *server)

fs/smb/client/smb1ops.c

1279

if (server->tcpStatus == CifsGood)

fs/smb/client/smb1ops.c

1349

cifs_is_network_name_deleted(char *buf, struct TCP_Server_Info *server)

fs/smb/client/smb1ops.c

1366

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb1ops.c

144

send_nt_cancel(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb1ops.c

161

cifs_server_lock(server);

fs/smb/client/smb1ops.c

162

rc = cifs_sign_rqst(&crqst, server, &mid->sequence_number);

fs/smb/client/smb1ops.c

164

cifs_server_unlock(server);

fs/smb/client/smb1ops.c

173

--server->sequence_number;

fs/smb/client/smb1ops.c

174

rc = __smb_send_rqst(server, 1, &crqst);

fs/smb/client/smb1ops.c

176

server->sequence_number--;

fs/smb/client/smb1ops.c

178

cifs_server_unlock(server);

fs/smb/client/smb1ops.c

191

send_lock_cancel(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb1ops.c

207

pSMB->hdr.Mid = get_next_mid(ses->server);

fs/smb/client/smb1ops.c

217

static int cifs_send_cancel(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb1ops.c

222

return send_lock_cancel(ses, server, rqst, mid, xid);

fs/smb/client/smb1ops.c

223

return send_nt_cancel(ses, server, rqst, mid, xid);

fs/smb/client/smb1ops.c

250

cifs_find_mid(struct TCP_Server_Info *server, char *buffer)

fs/smb/client/smb1ops.c

255

spin_lock(&server->mid_queue_lock);

fs/smb/client/smb1ops.c

256

list_for_each_entry(mid, &server->pending_mid_q, qhead) {

fs/smb/client/smb1ops.c

261

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb1ops.c

265

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb1ops.c

270

cifs_add_credits(struct TCP_Server_Info *server,

fs/smb/client/smb1ops.c

273

spin_lock(&server->req_lock);

fs/smb/client/smb1ops.c

274

server->credits += credits->value;

fs/smb/client/smb1ops.c

275

server->in_flight--;

fs/smb/client/smb1ops.c

276

spin_unlock(&server->req_lock);

fs/smb/client/smb1ops.c

277

wake_up(&server->request_q);

fs/smb/client/smb1ops.c

281

cifs_set_credits(struct TCP_Server_Info *server, const int val)

fs/smb/client/smb1ops.c

283

spin_lock(&server->req_lock);

fs/smb/client/smb1ops.c

284

server->credits = val;

fs/smb/client/smb1ops.c

285

server->oplocks = val > 1 ? enable_oplocks : false;

fs/smb/client/smb1ops.c

286

spin_unlock(&server->req_lock);

fs/smb/client/smb1ops.c

290

cifs_get_credits_field(struct TCP_Server_Info *server, const int optype)

fs/smb/client/smb1ops.c

292

return &server->credits;

fs/smb/client/smb1ops.c

323

cifs_get_next_mid(struct TCP_Server_Info *server)

fs/smb/client/smb1ops.c

329

spin_lock(&server->mid_counter_lock);

fs/smb/client/smb1ops.c

331

cur_mid = (__u16)((server->current_mid) & 0xffff);

fs/smb/client/smb1ops.c

357

spin_lock(&server->mid_queue_lock);

fs/smb/client/smb1ops.c

358

list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {

fs/smb/client/smb1ops.c

367

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb1ops.c

384

server->current_mid = mid;

fs/smb/client/smb1ops.c

389

spin_unlock(&server->mid_counter_lock);

fs/smb/client/smb1ops.c

392

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/smb1ops.c

399

cifs_downgrade_oplock(struct TCP_Server_Info *server,

fs/smb/client/smb1ops.c

408

cifs_need_neg(struct TCP_Server_Info *server)

fs/smb/client/smb1ops.c

410

return server->maxBuf == 0;

fs/smb/client/smb1ops.c

416

struct TCP_Server_Info *server)

fs/smb/client/smb1ops.c

419

rc = CIFSSMBNegotiate(xid, ses, server);

fs/smb/client/smb1ops.c

427

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb1ops.c

447

if (!(server->capabilities & CAP_LARGE_WRITE_X) ||

fs/smb/client/smb1ops.c

448

(!(server->capabilities & CAP_UNIX) && server->sign))

fs/smb/client/smb1ops.c

450

server->maxBuf - sizeof(WRITE_REQ));

fs/smb/client/smb1ops.c

462

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb1ops.c

479

else if (server->capabilities & CAP_LARGE_READ_X)

fs/smb/client/smb1ops.c

482

defsize = server->maxBuf - sizeof(READ_RSP);

fs/smb/client/smb1ops.c

490

if (!(server->capabilities & CAP_LARGE_READ_X))

fs/smb/client/smb1ops.c

571

if (!(tcon->ses->capabilities & tcon->ses->server->vals->cap_nt_find))

fs/smb/client/smb1ops.c

579

if (!(tcon->ses->capabilities & tcon->ses->server->vals->cap_nt_find)) {

fs/smb/client/smb1ops.c

581

int offset = tcon->ses->server->timeAdj;

fs/smb/client/smb1proto.h

222

struct TCP_Server_Info *server);

fs/smb/client/smb1proto.h

227

int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

230

struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

237

int map_and_check_smb_error(struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

262

struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

268

struct mid_q_entry *cifs_setup_async_request(struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

272

int cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

275

struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

284

bool cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb1proto.h

287

struct TCP_Server_Info *server);

fs/smb/client/smb1proto.h

34

struct TCP_Server_Info *server);

fs/smb/client/smb1proto.h

38

int CIFSSMBEcho(struct TCP_Server_Info *server);

fs/smb/client/smb1session.c

22

struct TCP_Server_Info *server;

fs/smb/client/smb1session.c

371

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

373

cifs_server_lock(server);

fs/smb/client/smb1session.c

374

if (!server->session_estab) {

fs/smb/client/smb1session.c

375

if (server->sign) {

fs/smb/client/smb1session.c

376

server->session_key.response =

fs/smb/client/smb1session.c

379

if (!server->session_key.response) {

fs/smb/client/smb1session.c

380

cifs_server_unlock(server);

fs/smb/client/smb1session.c

383

server->session_key.len =

fs/smb/client/smb1session.c

386

server->sequence_number = 0x2;

fs/smb/client/smb1session.c

387

server->session_estab = true;

fs/smb/client/smb1session.c

389

cifs_server_unlock(server);

fs/smb/client/smb1session.c

40

struct TCP_Server_Info *server,

fs/smb/client/smb1session.c

425

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

437

capabilities = cifs_ssetup_hdr(ses, server, pSMB);

fs/smb/client/smb1session.c

535

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

54

pSMB->req.MaxMpxCount = cpu_to_le16(server->maxReq);

fs/smb/client/smb1session.c

550

capabilities = cifs_ssetup_hdr(ses, server, pSMB);

fs/smb/client/smb1session.c

552

spnego_key = cifs_get_spnego_key(ses, server);

fs/smb/client/smb1session.c

56

pSMB->req.SessionKey = server->session_key_id;

fs/smb/client/smb1session.c

65

if (server->sign)

fs/smb/client/smb1session.c

676

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

682

capabilities = cifs_ssetup_hdr(ses, server, pSMB);

fs/smb/client/smb1session.c

716

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

744

&blob_len, ses, server,

fs/smb/client/smb1session.c

822

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

839

&blob_len, ses, server,

fs/smb/client/smb1session.c

928

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb1session.c

930

type = cifs_select_sectype(server, ses->sectype);

fs/smb/client/smb1session.c

961

struct TCP_Server_Info *server,

fs/smb/client/smb1session.c

978

sess_data->server = server;

fs/smb/client/smb1transport.c

100

spin_unlock(&ses->server->mid_queue_lock);

fs/smb/client/smb1transport.c

105

cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)

fs/smb/client/smb1transport.c

112

if (server->sign)

fs/smb/client/smb1transport.c

115

mid = alloc_mid(hdr, server);

fs/smb/client/smb1transport.c

119

rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);

fs/smb/client/smb1transport.c

121

release_mid(server, mid);

fs/smb/client/smb1transport.c

156

cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb1transport.c

164

if (server->sign) {

fs/smb/client/smb1transport.c

173

rc = cifs_verify_signature(&rqst, server,

fs/smb/client/smb1transport.c

179

if (!(server->sec_mode & SECMODE_SIGN_REQUIRED)) {

fs/smb/client/smb1transport.c

180

cifs_reconnect(server, true);

fs/smb/client/smb1transport.c

187

return map_and_check_smb_error(server, mid, log_error);

fs/smb/client/smb1transport.c

191

cifs_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb1transport.c

201

rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);

fs/smb/client/smb1transport.c

203

delete_mid(server, mid);

fs/smb/client/smb1transport.c

219

return cifs_send_recv(xid, ses, ses->server,

fs/smb/client/smb1transport.c

228

struct TCP_Server_Info *server;

fs/smb/client/smb1transport.c

241

server = ses->server;

fs/smb/client/smb1transport.c

242

if (server == NULL) {

fs/smb/client/smb1transport.c

257

rc = cifs_send_recv(xid, ses, ses->server,

fs/smb/client/smb1transport.c

37

alloc_mid(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)

fs/smb/client/smb1transport.c

41

if (server == NULL) {

fs/smb/client/smb1transport.c

414

cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb1transport.c

429

dequeue_mid(server, mid, malformed);

fs/smb/client/smb1transport.c

432

if (!server->large_buf) {

fs/smb/client/smb1transport.c

439

server->bigbuf = NULL;

fs/smb/client/smb1transport.c

477

struct TCP_Server_Info *server)

fs/smb/client/smb1transport.c

95

*ppmidQ = alloc_mid(in_buf, ses->server);

fs/smb/client/smb1transport.c

98

spin_lock(&ses->server->mid_queue_lock);

fs/smb/client/smb1transport.c

99

list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);

fs/smb/client/smb2file.c

277

max_buf = tcon->ses->server->maxBuf;

fs/smb/client/smb2file.c

418

max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;

fs/smb/client/smb2inode.c

1192

struct TCP_Server_Info *server;

fs/smb/client/smb2inode.c

1213

server = cifs_pick_channel(tcon->ses);

fs/smb/client/smb2inode.c

1230

if (CIFS_I(inode)->lease_granted && server->ops->get_lease_key) {

fs/smb/client/smb2inode.c

1232

server->ops->get_lease_key(inode, &fid);

fs/smb/client/smb2inode.c

1236

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2inode.c

1248

rc = SMB2_close_init(tcon, server, &rqst[1],

fs/smb/client/smb2inode.c

1259

smb2_set_replay(server, &rqst[i]);

fs/smb/client/smb2inode.c

1262

rc = compound_send_recv(xid, tcon->ses, server, flags,

fs/smb/client/smb2inode.c

189

struct TCP_Server_Info *server;

fs/smb/client/smb2inode.c

210

server = cifs_pick_channel(ses);

fs/smb/client/smb2inode.c

251

if (CIFS_I(inode)->lease_granted && server->ops->get_lease_key) {

fs/smb/client/smb2inode.c

253

server->ops->get_lease_key(inode, &fid);

fs/smb/client/smb2inode.c

262

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2inode.c

288

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

297

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

322

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

332

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

367

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

376

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

402

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

411

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

437

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

444

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

478

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

485

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

516

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2inode.c

532

rc = SMB2_ioctl_init(tcon, server, &rqst[num_rqst],

fs/smb/client/smb2inode.c

539

rc = SMB2_ioctl_init(tcon, server, &rqst[num_rqst],

fs/smb/client/smb2inode.c

560

rc = SMB2_ioctl_init(tcon, server, &rqst[num_rqst],

fs/smb/client/smb2inode.c

566

rc = SMB2_ioctl_init(tcon, server, &rqst[num_rqst],

fs/smb/client/smb2inode.c

586

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

596

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2inode.c

631

rc = SMB2_close_init(tcon, server,

fs/smb/client/smb2inode.c

646

smb2_set_replay(server, &rqst[i]);

fs/smb/client/smb2inode.c

649

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2inode.c

659

smb2_set_replay(server, &rqst[i]);

fs/smb/client/smb2inode.c

662

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2inode.c

694

rc = smb2_parse_contexts(server, &rsp_iov[0], &oparms->fid->epoch,

fs/smb/client/smb2inode.c

704

rc = server->ops->map_error(buf, false);

fs/smb/client/smb2misc.c

138

struct TCP_Server_Info *server)

fs/smb/client/smb2misc.c

150

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2misc.c

601

smb2_is_valid_lease_break(char *buffer, struct TCP_Server_Info *server)

fs/smb/client/smb2misc.c

621

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2misc.c

675

smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server)

fs/smb/client/smb2misc.c

692

return smb2_is_valid_lease_break(buffer, server);

fs/smb/client/smb2misc.c

700

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2misc.c

815

struct TCP_Server_Info *server = NULL;

fs/smb/client/smb2misc.c

823

server = tcon->ses->server;

fs/smb/client/smb2misc.c

845

smb2_handle_cancelled_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server)

fs/smb/client/smb2misc.c

856

tcon = smb2_find_smb_tcon(server, le64_to_cpu(hdr->SessionId),

fs/smb/client/smb2misc.c

884

smb311_update_preauth_hash(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb2misc.c

901

if (server->dialect != SMB311_PROT_ID)

fs/smb/client/smb2ops.c

104

if (WARN_ON_ONCE(server->in_flight == 0)) {

fs/smb/client/smb2ops.c

110

server->credits, server->in_flight, 0,

fs/smb/client/smb2ops.c

113

server->in_flight--;

fs/smb/client/smb2ops.c

114

if (server->in_flight == 0 &&

fs/smb/client/smb2ops.c

117

rc = change_conf(server);

fs/smb/client/smb2ops.c

1177

struct TCP_Server_Info *server;

fs/smb/client/smb2ops.c

1200

server = cifs_pick_channel(ses);

fs/smb/client/smb2ops.c

122

else if (server->in_flight > 0 && server->oplock_credits == 0 &&

fs/smb/client/smb2ops.c

1222

if (ses->server->ops->query_all_EAs) {

fs/smb/client/smb2ops.c

1224

rc = ses->server->ops->query_all_EAs(xid, tcon, path,

fs/smb/client/smb2ops.c

123

server->oplocks) {

fs/smb/client/smb2ops.c

124

if (server->credits > 1) {

fs/smb/client/smb2ops.c

125

server->credits--;

fs/smb/client/smb2ops.c

126

server->oplock_credits++;

fs/smb/client/smb2ops.c

1278

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2ops.c

128

} else if ((server->in_flight > 0) && (server->oplock_credits > 3) &&

fs/smb/client/smb2ops.c

1304

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2ops.c

131

change_conf(server);

fs/smb/client/smb2ops.c

1317

rc = SMB2_close_init(tcon, server,

fs/smb/client/smb2ops.c

1327

smb2_set_replay(server, &rqst[0]);

fs/smb/client/smb2ops.c

1328

smb2_set_replay(server, &rqst[1]);

fs/smb/client/smb2ops.c

1329

smb2_set_replay(server, &rqst[2]);

fs/smb/client/smb2ops.c

1332

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2ops.c

134

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

135

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

1358

smb2_can_echo(struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

136

wake_up(&server->request_q);

fs/smb/client/smb2ops.c

1360

return server->echoes;

fs/smb/client/smb2ops.c

139

trace_smb3_reconnect_detected(server->current_mid,

fs/smb/client/smb2ops.c

140

server->conn_id, server->hostname, scredits, add, in_flight);

fs/smb/client/smb2ops.c

147

trace_smb3_reconnect_with_invalid_credits(server->current_mid,

fs/smb/client/smb2ops.c

1471

struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;

fs/smb/client/smb2ops.c

148

server->conn_id, server->hostname, scredits, add, in_flight);

fs/smb/client/smb2ops.c

1481

server->ops->set_oplock_level(cinode, oplock, fid->epoch,

fs/smb/client/smb2ops.c

153

spin_lock(&server->srv_lock);

fs/smb/client/smb2ops.c

154

if (server->tcpStatus == CifsNeedReconnect

fs/smb/client/smb2ops.c

155

|| server->tcpStatus == CifsExiting) {

fs/smb/client/smb2ops.c

156

spin_unlock(&server->srv_lock);

fs/smb/client/smb2ops.c

1576

struct TCP_Server_Info *server;

fs/smb/client/smb2ops.c

159

spin_unlock(&server->srv_lock);

fs/smb/client/smb2ops.c

1600

server = cifs_pick_channel(ses);

fs/smb/client/smb2ops.c

1619

if (!ses || !server) {

fs/smb/client/smb2ops.c

1668

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2ops.c

1684

rc = SMB2_ioctl_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,

fs/smb/client/smb2ops.c

1706

rc = SMB2_set_info_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,

fs/smb/client/smb2ops.c

1714

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2ops.c

1736

rc = SMB2_close_init(tcon, server,

fs/smb/client/smb2ops.c

1746

smb2_set_replay(server, &rqst[0]);

fs/smb/client/smb2ops.c

1747

smb2_set_replay(server, &rqst[1]);

fs/smb/client/smb2ops.c

1748

smb2_set_replay(server, &rqst[2]);

fs/smb/client/smb2ops.c

1751

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2ops.c

179

trace_smb3_add_credits(server->current_mid,

fs/smb/client/smb2ops.c

180

server->conn_id, server->hostname, scredits, add, in_flight);

fs/smb/client/smb2ops.c

185

smb2_set_credits(struct TCP_Server_Info *server, const int val)

fs/smb/client/smb2ops.c

189

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

190

server->credits = val;

fs/smb/client/smb2ops.c

192

server->reconnect_instance++;

fs/smb/client/smb2ops.c

197

if (SERVER_IS_CHAN(server))

fs/smb/client/smb2ops.c

198

server->primary_server->channel_sequence_num++;

fs/smb/client/smb2ops.c

200

server->channel_sequence_num++;

fs/smb/client/smb2ops.c

202

scredits = server->credits;

fs/smb/client/smb2ops.c

203

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

204

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

206

trace_smb3_set_credits(server->current_mid,

fs/smb/client/smb2ops.c

207

server->conn_id, server->hostname, scredits, val, in_flight);

fs/smb/client/smb2ops.c

216

smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)

fs/smb/client/smb2ops.c

220

return &server->echo_credits;

fs/smb/client/smb2ops.c

222

return &server->oplock_credits;

fs/smb/client/smb2ops.c

224

return &server->credits;

fs/smb/client/smb2ops.c

235

smb2_wait_mtu_credits(struct TCP_Server_Info *server, size_t size,

fs/smb/client/smb2ops.c

241

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

243

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

245

spin_lock(&server->srv_lock);

fs/smb/client/smb2ops.c

2452

struct TCP_Server_Info *server;

fs/smb/client/smb2ops.c

2459

server = cifs_pick_channel(tcon->ses);

fs/smb/client/smb2ops.c

246

if (server->tcpStatus == CifsExiting) {

fs/smb/client/smb2ops.c

247

spin_unlock(&server->srv_lock);

fs/smb/client/smb2ops.c

2487

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2ops.c

250

spin_unlock(&server->srv_lock);

fs/smb/client/smb2ops.c

2501

rc = SMB2_query_directory_init(xid, tcon, server,

fs/smb/client/smb2ops.c

2514

smb2_set_replay(server, &rqst[0]);

fs/smb/client/smb2ops.c

2515

smb2_set_replay(server, &rqst[1]);

fs/smb/client/smb2ops.c

2518

rc = compound_send_recv(xid, tcon->ses, server,

fs/smb/client/smb2ops.c

252

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

253

if (server->credits <= 0) {

fs/smb/client/smb2ops.c

254

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

255

cifs_num_waiters_inc(server);

fs/smb/client/smb2ops.c

256

rc = wait_event_killable(server->request_q,

fs/smb/client/smb2ops.c

257

has_credits(server, &server->credits, 1));

fs/smb/client/smb2ops.c

258

cifs_num_waiters_dec(server);

fs/smb/client/smb2ops.c

2598

smb2_is_status_pending(char *buf, struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

2607

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

2608

server->credits += le16_to_cpu(shdr->CreditRequest);

fs/smb/client/smb2ops.c

2609

scredits = server->credits;

fs/smb/client/smb2ops.c

261

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

2610

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

2611

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

2612

wake_up(&server->request_q);

fs/smb/client/smb2ops.c

2614

trace_smb3_pend_credits(server->current_mid,

fs/smb/client/smb2ops.c

2615

server->conn_id, server->hostname, scredits,

fs/smb/client/smb2ops.c

263

scredits = server->credits;

fs/smb/client/smb2ops.c

2654

smb2_is_network_name_deleted(char *buf, struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

2665

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2ops.c

2695

if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)

fs/smb/client/smb2ops.c

2704

smb2_set_replay(struct TCP_Server_Info *server, struct smb_rqst *rqst)

fs/smb/client/smb2ops.c

2708

if (server->dialect < SMB30_PROT_ID)

fs/smb/client/smb2ops.c

2739

struct TCP_Server_Info *server = ses->server;

fs/smb/client/smb2ops.c

2740

unsigned long len = smb_rqst_len(server, rqst);

fs/smb/client/smb2ops.c

279

credits->instance = server->reconnect_instance;

fs/smb/client/smb2ops.c

2792

if (tcon->retry || (*pretries)++ < tcon->ses->server->retrans) {

fs/smb/client/smb2ops.c

280

server->credits -= credits->value;

fs/smb/client/smb2ops.c

281

server->in_flight++;

fs/smb/client/smb2ops.c

282

if (server->in_flight > server->max_in_flight)

fs/smb/client/smb2ops.c

2820

struct TCP_Server_Info *server;

fs/smb/client/smb2ops.c

283

server->max_in_flight = server->in_flight;

fs/smb/client/smb2ops.c

2838

server = cifs_pick_channel(ses);

fs/smb/client/smb2ops.c

287

scredits = server->credits;

fs/smb/client/smb2ops.c

2878

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2ops.c

288

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

2888

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2ops.c

289

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

2896

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2ops.c

291

trace_smb3_wait_credits(server->current_mid,

fs/smb/client/smb2ops.c

2914

rc = SMB2_close_init(tcon, server,

fs/smb/client/smb2ops.c

292

server->conn_id, server->hostname, scredits, -(credits->value), in_flight);

fs/smb/client/smb2ops.c

2925

smb2_set_replay(server, &rqst[0]);

fs/smb/client/smb2ops.c

2926

smb2_set_replay(server, &rqst[2]);

fs/smb/client/smb2ops.c

2928

smb2_set_replay(server, &rqst[1]);

fs/smb/client/smb2ops.c

2932

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2ops.c

2936

rc = compound_send_recv(xid, ses, server,

fs/smb/client/smb2ops.c

300

smb2_adjust_credits(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

316

server->credits, server->in_flight,

fs/smb/client/smb2ops.c

319

trace_smb3_too_many_credits(server->current_mid,

fs/smb/client/smb2ops.c

320

server->conn_id, server->hostname, 0, credits->value - new_val, 0);

fs/smb/client/smb2ops.c

328

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

330

if (server->reconnect_instance != credits->instance) {

fs/smb/client/smb2ops.c

331

scredits = server->credits;

fs/smb/client/smb2ops.c

332

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

333

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

338

server->credits, server->in_flight,

fs/smb/client/smb2ops.c

341

trace_smb3_reconnect_detected(server->current_mid,

fs/smb/client/smb2ops.c

342

server->conn_id, server->hostname, scredits,

fs/smb/client/smb2ops.c

353

server->credits, server->in_flight,

fs/smb/client/smb2ops.c

355

server->credits += credits->value - new_val;

fs/smb/client/smb2ops.c

356

scredits = server->credits;

fs/smb/client/smb2ops.c

357

in_flight = server->in_flight;

fs/smb/client/smb2ops.c

358

spin_unlock(&server->req_lock);

fs/smb/client/smb2ops.c

359

wake_up(&server->request_q);

fs/smb/client/smb2ops.c

36

change_conf(struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

361

trace_smb3_adj_credits(server->current_mid,

fs/smb/client/smb2ops.c

362

server->conn_id, server->hostname, scredits,

fs/smb/client/smb2ops.c

373

smb2_get_next_mid(struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

377

spin_lock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

378

mid = server->current_mid++;

fs/smb/client/smb2ops.c

379

spin_unlock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

38

server->credits += server->echo_credits + server->oplock_credits;

fs/smb/client/smb2ops.c

384

smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)

fs/smb/client/smb2ops.c

386

spin_lock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

387

if (server->current_mid >= val)

fs/smb/client/smb2ops.c

388

server->current_mid -= val;

fs/smb/client/smb2ops.c

389

spin_unlock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

39

if (server->credits > server->max_credits)

fs/smb/client/smb2ops.c

393

__smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue)

fs/smb/client/smb2ops.c

40

server->credits = server->max_credits;

fs/smb/client/smb2ops.c

404

spin_lock(&server->mid_queue_lock);

fs/smb/client/smb2ops.c

405

list_for_each_entry(mid, &server->pending_mid_q, qhead) {

fs/smb/client/smb2ops.c

4054

smb2_downgrade_oplock(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

4059

server->ops->set_oplock_level(cinode, oplock, 0, NULL);

fs/smb/client/smb2ops.c

4067

smb3_downgrade_oplock(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

41

server->oplock_credits = server->echo_credits = 0;

fs/smb/client/smb2ops.c

414

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb2ops.c

418

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb2ops.c

42

switch (server->credits) {

fs/smb/client/smb2ops.c

423

smb2_find_mid(struct TCP_Server_Info *server, char *buf)

fs/smb/client/smb2ops.c

425

return __smb2_find_mid(server, buf, false);

fs/smb/client/smb2ops.c

429

smb2_find_dequeue_mid(struct TCP_Server_Info *server, char *buf)

fs/smb/client/smb2ops.c

431

return __smb2_find_mid(server, buf, true);

fs/smb/client/smb2ops.c

435

smb2_dump_detail(void *buf, size_t buf_len, struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

4408

smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key)

fs/smb/client/smb2ops.c

4415

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2ops.c

443

if (!server->ops->check_message(buf, buf_len, server->total_read, server)) {

fs/smb/client/smb2ops.c

4443

crypt_message(struct TCP_Server_Info *server, int num_rqst,

fs/smb/client/smb2ops.c

445

server->ops->calc_smb_size(buf));

fs/smb/client/smb2ops.c

4459

rc = smb2_get_enc_key(server, le64_to_cpu(tr_hdr->SessionId), enc, key);

fs/smb/client/smb2ops.c

4466

if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||

fs/smb/client/smb2ops.c

4467

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))

fs/smb/client/smb2ops.c

4492

if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||

fs/smb/client/smb2ops.c

4493

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))

fs/smb/client/smb2ops.c

451

smb2_need_neg(struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

453

return server->max_read == 0;

fs/smb/client/smb2ops.c

4559

smb3_init_transform_rq(struct TCP_Server_Info *server, int num_rqst,

fs/smb/client/smb2ops.c

4572

orig_len += smb_rqst_len(server, old);

fs/smb/client/smb2ops.c

459

struct TCP_Server_Info *server)

fs/smb/client/smb2ops.c

4595

fill_transform_hdr(tr_hdr, orig_len, old_rq, server->cipher_type);

fs/smb/client/smb2ops.c

4597

rc = crypt_message(server, num_rqst, new_rq, 1, server->secmech.enc);

fs/smb/client/smb2ops.c

46

server->echoes = false;

fs/smb/client/smb2ops.c

4618

decrypt_raw_data(struct TCP_Server_Info *server, char *buf,

fs/smb/client/smb2ops.c

463

spin_lock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

464

server->current_mid = 0;

fs/smb/client/smb2ops.c

4641

if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||

fs/smb/client/smb2ops.c

4642

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))

fs/smb/client/smb2ops.c

465

spin_unlock(&server->mid_counter_lock);

fs/smb/client/smb2ops.c

4653

rc = smb3_crypto_aead_allocate(server);

fs/smb/client/smb2ops.c

4656

tfm = server->secmech.dec;

fs/smb/client/smb2ops.c

4659

rc = crypt_message(server, 1, &rqst, 0, tfm);

fs/smb/client/smb2ops.c

466

rc = SMB2_negotiate(xid, ses, server);

fs/smb/client/smb2ops.c

4671

server->total_read = buf_data_size + iter_size;

fs/smb/client/smb2ops.c

47

server->oplocks = false;

fs/smb/client/smb2ops.c

4701

handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,

fs/smb/client/smb2ops.c

4720

if (server->ops->is_session_expired &&

fs/smb/client/smb2ops.c

4721

server->ops->is_session_expired(buf)) {

fs/smb/client/smb2ops.c

4723

cifs_reconnect(server, true);

fs/smb/client/smb2ops.c

4727

if (server->ops->is_status_pending &&

fs/smb/client/smb2ops.c

4728

server->ops->is_status_pending(buf, server))

fs/smb/client/smb2ops.c

4736

min_t(unsigned int, buf_len, server->vals->read_rsp_size);

fs/smb/client/smb2ops.c

4742

rdata->result = server->ops->map_error(buf, true);

fs/smb/client/smb2ops.c

4750

dequeue_mid(server, mid, false);

fs/smb/client/smb2ops.c

4754

data_offset = server->ops->read_data_offset(buf);

fs/smb/client/smb2ops.c

4758

data_len = server->ops->read_data_length(buf, use_rdma_mr);

fs/smb/client/smb2ops.c

4760

if (data_offset < server->vals->read_rsp_size) {

fs/smb/client/smb2ops.c

4768

data_offset = server->vals->read_rsp_size;

fs/smb/client/smb2ops.c

4777

dequeue_mid(server, mid, rdata->result);

fs/smb/client/smb2ops.c

4781

pad_len = data_offset - server->vals->read_rsp_size;

fs/smb/client/smb2ops.c

4796

dequeue_mid(server, mid, rdata->result);

fs/smb/client/smb2ops.c

4806

dequeue_mid(server, mid, rdata->result);

fs/smb/client/smb2ops.c

4817

dequeue_mid(server, mid, rdata->result);

fs/smb/client/smb2ops.c

4836

dequeue_mid(server, mid, rdata->result);

fs/smb/client/smb2ops.c

484

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2ops.c

4843

dequeue_mid(server, mid, false);

fs/smb/client/smb2ops.c

4849

struct TCP_Server_Info *server;

fs/smb/client/smb2ops.c

4865

rc = decrypt_raw_data(dw->server, dw->buf, dw->server->vals->read_rsp_size,

fs/smb/client/smb2ops.c

4872

dw->server->lstrp = jiffies;

fs/smb/client/smb2ops.c

4873

mid = smb2_find_dequeue_mid(dw->server, dw->buf);

fs/smb/client/smb2ops.c

4878

rc = handle_read_data(dw->server, mid, dw->buf,

fs/smb/client/smb2ops.c

4879

dw->server->vals->read_rsp_size,

fs/smb/client/smb2ops.c

4886

if (dw->server->ops->is_network_name_deleted)

fs/smb/client/smb2ops.c

4887

dw->server->ops->is_network_name_deleted(dw->buf,

fs/smb/client/smb2ops.c

4888

dw->server);

fs/smb/client/smb2ops.c

489

wsize = min_t(unsigned int, wsize, server->max_write);

fs/smb/client/smb2ops.c

4890

mid_execute_callback(dw->server, mid);

fs/smb/client/smb2ops.c

4892

spin_lock(&dw->server->srv_lock);

fs/smb/client/smb2ops.c

4893

if (dw->server->tcpStatus == CifsNeedReconnect) {

fs/smb/client/smb2ops.c

4894

spin_lock(&dw->server->mid_queue_lock);

fs/smb/client/smb2ops.c

4896

spin_unlock(&dw->server->mid_queue_lock);

fs/smb/client/smb2ops.c

4897

spin_unlock(&dw->server->srv_lock);

fs/smb/client/smb2ops.c

4898

mid_execute_callback(dw->server, mid);

fs/smb/client/smb2ops.c

490

if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))

fs/smb/client/smb2ops.c

4900

spin_lock(&dw->server->mid_queue_lock);

fs/smb/client/smb2ops.c

4904

&dw->server->pending_mid_q);

fs/smb/client/smb2ops.c

4905

spin_unlock(&dw->server->mid_queue_lock);

fs/smb/client/smb2ops.c

4906

spin_unlock(&dw->server->srv_lock);

fs/smb/client/smb2ops.c

4909

release_mid(dw->server, mid);

fs/smb/client/smb2ops.c

4920

receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid,

fs/smb/client/smb2ops.c

4923

char *buf = server->smallbuf;

fs/smb/client/smb2ops.c

4927

unsigned int buflen = server->pdu_size;

fs/smb/client/smb2ops.c

4935

dw->server = server;

fs/smb/client/smb2ops.c

4938

len = min_t(unsigned int, buflen, server->vals->read_rsp_size +

fs/smb/client/smb2ops.c

4939

sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1;

fs/smb/client/smb2ops.c

4941

rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len);

fs/smb/client/smb2ops.c

4944

server->total_read += rc;

fs/smb/client/smb2ops.c

4947

server->vals->read_rsp_size;

fs/smb/client/smb2ops.c

4959

rc = cifs_read_iter_from_socket(server, &iter, dw->len);

fs/smb/client/smb2ops.c

4963

server->total_read += rc;

fs/smb/client/smb2ops.c

4972

rc = cifs_discard_remaining_data(server);

fs/smb/client/smb2ops.c

4981

if ((server->min_offload) && (server->in_flight > 1) &&

fs/smb/client/smb2ops.c

4982

(server->pdu_size >= server->min_offload)) {

fs/smb/client/smb2ops.c

4983

dw->buf = server->smallbuf;

fs/smb/client/smb2ops.c

4984

server->smallbuf = (char *)cifs_small_buf_get();

fs/smb/client/smb2ops.c

499

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2ops.c

4991

rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size,

fs/smb/client/smb2ops.c

4996

*mid = smb2_find_mid(server, buf);

fs/smb/client/smb2ops.c

50

server->echoes = true;

fs/smb/client/smb2ops.c

5002

rc = handle_read_data(server, *mid, buf,

fs/smb/client/smb2ops.c

5003

server->vals->read_rsp_size,

fs/smb/client/smb2ops.c

5006

if (server->ops->is_network_name_deleted) {

fs/smb/client/smb2ops.c

5007

server->ops->is_network_name_deleted(buf,

fs/smb/client/smb2ops.c

5008

server);

fs/smb/client/smb2ops.c

5019

cifs_discard_remaining_data(server);

fs/smb/client/smb2ops.c

5024

receive_encrypted_standard(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

5029

char *buf = server->smallbuf;

fs/smb/client/smb2ops.c

5031

unsigned int pdu_length = server->pdu_size;

fs/smb/client/smb2ops.c

504

wsize = min_t(unsigned int, wsize, server->max_write);

fs/smb/client/smb2ops.c

5042

server->large_buf = true;

fs/smb/client/smb2ops.c

5043

memcpy(server->bigbuf, buf, server->total_read);

fs/smb/client/smb2ops.c

5044

buf = server->bigbuf;

fs/smb/client/smb2ops.c

5048

length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,

fs/smb/client/smb2ops.c

5049

pdu_length - HEADER_SIZE(server) + 1);

fs/smb/client/smb2ops.c

5052

server->total_read += length;

fs/smb/client/smb2ops.c

5055

length = decrypt_raw_data(server, buf, buf_size, NULL, false);

fs/smb/client/smb2ops.c

5059

next_is_large = server->large_buf;

fs/smb/client/smb2ops.c

506

if (server->rdma) {

fs/smb/client/smb2ops.c

5077

mid_entry = smb2_find_mid(server, buf);

fs/smb/client/smb2ops.c

508

smbd_get_parameters(server->smbd_conn);

fs/smb/client/smb2ops.c

5083

mid_entry->resp_buf_size = server->pdu_size;

fs/smb/client/smb2ops.c

5094

ret = mid_entry->handle(server, mid_entry);

fs/smb/client/smb2ops.c

5096

ret = cifs_handle_standard(server, mid_entry);

fs/smb/client/smb2ops.c

51

server->oplocks = false;

fs/smb/client/smb2ops.c

510

if (server->sign)

fs/smb/client/smb2ops.c

5100

server->large_buf = next_is_large;

fs/smb/client/smb2ops.c

5102

server->bigbuf = buf = next_buffer;

fs/smb/client/smb2ops.c

5104

server->smallbuf = buf = next_buffer;

fs/smb/client/smb2ops.c

5123

smb3_receive_transform(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

5126

char *buf = server->smallbuf;

fs/smb/client/smb2ops.c

5127

unsigned int pdu_length = server->pdu_size;

fs/smb/client/smb2ops.c

5135

cifs_reconnect(server, true);

fs/smb/client/smb2ops.c

5141

cifs_reconnect(server, true);

fs/smb/client/smb2ops.c

5146

if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {

fs/smb/client/smb2ops.c

5147

return receive_encrypted_read(server, &mids[0], num_mids);

fs/smb/client/smb2ops.c

5150

return receive_encrypted_standard(server, mids, bufs, num_mids);

fs/smb/client/smb2ops.c

5154

smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/smb2ops.c

5156

char *buf = server->large_buf ? server->bigbuf : server->smallbuf;

fs/smb/client/smb2ops.c

5158

return handle_read_data(server, mid, buf, server->pdu_size,

fs/smb/client/smb2ops.c

5162

static int smb2_next_header(struct TCP_Server_Info *server, char *buf,

fs/smb/client/smb2ops.c

5175

if (unlikely(*noff && *noff < MID_HEADER_SIZE(server)))

fs/smb/client/smb2ops.c

5185

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2ops.c

52

server->echo_credits = 1;

fs/smb/client/smb2ops.c

5202

__u32 oplock = server->oplocks ? REQ_OPLOCK : 0;

fs/smb/client/smb2ops.c

525

if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))

fs/smb/client/smb2ops.c

5257

rc = server->ops->open(xid, &oparms, &oplock, &idata);

fs/smb/client/smb2ops.c

5280

rc = server->ops->sync_write(xid, &fid, &io_parms,

fs/smb/client/smb2ops.c

5286

server->ops->close(xid, tcon, &fid);

fs/smb/client/smb2ops.c

5295

server->ops->unlink(xid, tcon, full_path, cifs_sb, NULL);

fs/smb/client/smb2ops.c

534

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2ops.c

539

rsize = min_t(unsigned int, rsize, server->max_read);

fs/smb/client/smb2ops.c

541

if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))

fs/smb/client/smb2ops.c

55

server->echoes = true;

fs/smb/client/smb2ops.c

550

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2ops.c

555

rsize = min_t(unsigned int, rsize, server->max_read);

fs/smb/client/smb2ops.c

557

if (server->rdma) {

fs/smb/client/smb2ops.c

559

smbd_get_parameters(server->smbd_conn);

fs/smb/client/smb2ops.c

561

if (server->sign)

fs/smb/client/smb2ops.c

57

server->oplocks = true;

fs/smb/client/smb2ops.c

577

if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))

fs/smb/client/smb2ops.c

58

server->oplock_credits = 1;

fs/smb/client/smb2ops.c

60

server->oplocks = false;

fs/smb/client/smb2ops.c

62

server->echo_credits = 1;

fs/smb/client/smb2ops.c

64

server->credits -= server->echo_credits + server->oplock_credits;

fs/smb/client/smb2ops.c

65

return server->credits + server->echo_credits + server->oplock_credits;

fs/smb/client/smb2ops.c

661

ses->server->hostname);

fs/smb/client/smb2ops.c

666

spin_lock(&ses->server->srv_lock);

fs/smb/client/smb2ops.c

667

if (ses->server->dstaddr.ss_family == AF_INET)

fs/smb/client/smb2ops.c

668

port = ((struct sockaddr_in *)&ses->server->dstaddr)->sin_port;

fs/smb/client/smb2ops.c

669

else if (ses->server->dstaddr.ss_family == AF_INET6)

fs/smb/client/smb2ops.c

670

port = ((struct sockaddr_in6 *)&ses->server->dstaddr)->sin6_port;

fs/smb/client/smb2ops.c

673

spin_unlock(&ses->server->srv_lock);

fs/smb/client/smb2ops.c

69

smb2_add_credits(struct TCP_Server_Info *server,

fs/smb/client/smb2ops.c

79

spin_lock(&server->req_lock);

fs/smb/client/smb2ops.c

80

val = server->ops->get_credits_field(server, optype);

fs/smb/client/smb2ops.c

858

pserver = ses->chans[0].server;

fs/smb/client/smb2ops.c

86

if ((instance == 0) || (instance == server->reconnect_instance))

fs/smb/client/smb2ops.c

94

trace_smb3_overflow_credits(server->current_mid,

fs/smb/client/smb2ops.c

95

server->conn_id, server->hostname, *val,

fs/smb/client/smb2ops.c

96

add, server->in_flight);

fs/smb/client/smb2pdu.c

105

if (server) {

fs/smb/client/smb2pdu.c

107

if (server->dialect >= SMB30_PROT_ID) {

fs/smb/client/smb2pdu.c

1079

struct TCP_Server_Info *server)

fs/smb/client/smb2pdu.c

1095

if (!server) {

fs/smb/client/smb2pdu.c

1100

rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server,

fs/smb/client/smb2pdu.c

1107

memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE);

fs/smb/client/smb2pdu.c

1110

if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

1117

} else if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

1127

req->Dialects[0] = cpu_to_le16(server->vals->protocol_id);

fs/smb/client/smb2pdu.c

113

if (SERVER_IS_CHAN(server))

fs/smb/client/smb2pdu.c

1140

req->Capabilities = cpu_to_le32(server->vals->req_capabilities);

fs/smb/client/smb2pdu.c

1144

if (server->vals->protocol_id == SMB20_PROT_ID)

fs/smb/client/smb2pdu.c

1147

memcpy(req->ClientGUID, server->client_guid,

fs/smb/client/smb2pdu.c

1149

if ((server->vals->protocol_id == SMB311_PROT_ID) ||

fs/smb/client/smb2pdu.c

115

cpu_to_le16(server->primary_server->channel_sequence_num);

fs/smb/client/smb2pdu.c

1150

(strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

1152

(strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

1154

assemble_neg_contexts(req, server, &total_len);

fs/smb/client/smb2pdu.c

1163

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

1178

if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

118

cpu_to_le16(server->channel_sequence_num);

fs/smb/client/smb2pdu.c

1193

server->ops = &smb311_operations;

fs/smb/client/smb2pdu.c

1194

server->vals = &smb311_values;

fs/smb/client/smb2pdu.c

1199

} else if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

120

spin_lock(&server->req_lock);

fs/smb/client/smb2pdu.c

1209

server->ops = &smb21_operations;

fs/smb/client/smb2pdu.c

1210

server->vals = &smb21_values;

fs/smb/client/smb2pdu.c

1213

server->ops = &smb311_operations;

fs/smb/client/smb2pdu.c

1214

server->vals = &smb311_values;

fs/smb/client/smb2pdu.c

1219

} else if (dialect != server->vals->protocol_id) {

fs/smb/client/smb2pdu.c

122

if (server->credits >= server->max_credits)

fs/smb/client/smb2pdu.c

1224

dialect, server->vals->protocol_id);

fs/smb/client/smb2pdu.c

1254

server->dialect = dialect;

fs/smb/client/smb2pdu.c

126

min_t(int, server->max_credits -

fs/smb/client/smb2pdu.c

1261

memcpy(server->preauth_sha_hash, ses->preauth_sha_hash,

fs/smb/client/smb2pdu.c

1265

server->negflavor = CIFS_NEGFLAVOR_EXTENDED;

fs/smb/client/smb2pdu.c

1267

server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),

fs/smb/client/smb2pdu.c

1269

server->max_read = le32_to_cpu(rsp->MaxReadSize);

fs/smb/client/smb2pdu.c

127

server->credits, 10));

fs/smb/client/smb2pdu.c

1270

server->max_write = le32_to_cpu(rsp->MaxWriteSize);

fs/smb/client/smb2pdu.c

1271

server->sec_mode = le16_to_cpu(rsp->SecurityMode);

fs/smb/client/smb2pdu.c

1272

if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode)

fs/smb/client/smb2pdu.c

1274

server->sec_mode);

fs/smb/client/smb2pdu.c

1275

server->capabilities = le32_to_cpu(rsp->Capabilities);

fs/smb/client/smb2pdu.c

1277

server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;

fs/smb/client/smb2pdu.c

128

spin_unlock(&server->req_lock);

fs/smb/client/smb2pdu.c

1283

if ((server->dialect == SMB30_PROT_ID ||

fs/smb/client/smb2pdu.c

1284

server->dialect == SMB302_PROT_ID) &&

fs/smb/client/smb2pdu.c

1285

(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))

fs/smb/client/smb2pdu.c

1286

server->cipher_type = SMB2_ENCRYPTION_AES128_CCM;

fs/smb/client/smb2pdu.c

1299

server->sec_ntlmssp = true;

fs/smb/client/smb2pdu.c

1302

rc = cifs_enable_signing(server, ses->sign);

fs/smb/client/smb2pdu.c

1306

rc = decode_negTokenInit(security_blob, blob_length, server);

fs/smb/client/smb2pdu.c

1313

if (server->dialect == SMB311_PROT_ID) {

fs/smb/client/smb2pdu.c

1315

rc = smb311_decode_neg_context(rsp, server,

fs/smb/client/smb2pdu.c

1321

if (server->cipher_type && !rc)

fs/smb/client/smb2pdu.c

1322

rc = smb3_crypto_aead_allocate(server);

fs/smb/client/smb2pdu.c

1335

struct TCP_Server_Info *server = tcon->ses->server;

fs/smb/client/smb2pdu.c

1340

if (server->dialect == SMB311_PROT_ID)

fs/smb/client/smb2pdu.c

1366

cpu_to_le32(server->vals->req_capabilities);

fs/smb/client/smb2pdu.c

1369

memcpy(pneg_inbuf->Guid, server->client_guid,

fs/smb/client/smb2pdu.c

1382

if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

139

if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))

fs/smb/client/smb2pdu.c

1391

} else if (strcmp(server->vals->version_string,

fs/smb/client/smb2pdu.c

1403

cpu_to_le16(server->vals->protocol_id);

fs/smb/client/smb2pdu.c

1443

if (dialect != server->dialect) {

fs/smb/client/smb2pdu.c

1445

dialect, server->dialect);

fs/smb/client/smb2pdu.c

1451

if (sec_mode != server->sec_mode) {

fs/smb/client/smb2pdu.c

1453

sec_mode, server->sec_mode);

fs/smb/client/smb2pdu.c

1461

SMB2_LARGE_FILES) != server->capabilities) {

fs/smb/client/smb2pdu.c

1463

caps, server->capabilities);

fs/smb/client/smb2pdu.c

1482

smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)

fs/smb/client/smb2pdu.c

1491

if (server->sec_ntlmssp &&

fs/smb/client/smb2pdu.c

1494

if ((server->sec_kerberos || server->sec_mskerberos || server->sec_iakerb) &&

fs/smb/client/smb2pdu.c

1506

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

1528

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

1533

rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,

fs/smb/client/smb2pdu.c

1563

if (server->credits >= server->max_credits)

fs/smb/client/smb2pdu.c

1567

min_t(int, server->max_credits -

fs/smb/client/smb2pdu.c

1568

server->credits, 130));

fs/smb/client/smb2pdu.c

1571

if (server->sign)

fs/smb/client/smb2pdu.c

161

if (server && server->sign && !smb3_encryption_required(tcon))

fs/smb/client/smb2pdu.c

1630

sess_data->server,

fs/smb/client/smb2pdu.c

1639

trace_smb3_key_expired(sess_data->server->hostname,

fs/smb/client/smb2pdu.c

1641

sess_data->server->conn_id,

fs/smb/client/smb2pdu.c

1642

&sess_data->server->dstaddr, rc);

fs/smb/client/smb2pdu.c

1656

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

1658

cifs_server_lock(server);

fs/smb/client/smb2pdu.c

1659

if (server->ops->generate_signingkey) {

fs/smb/client/smb2pdu.c

1660

rc = server->ops->generate_signingkey(ses, server);

fs/smb/client/smb2pdu.c

1664

cifs_server_unlock(server);

fs/smb/client/smb2pdu.c

1668

if (!server->session_estab) {

fs/smb/client/smb2pdu.c

1669

server->sequence_number = 0x2;

fs/smb/client/smb2pdu.c

1670

server->session_estab = true;

fs/smb/client/smb2pdu.c

1672

cifs_server_unlock(server);

fs/smb/client/smb2pdu.c

1684

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

1694

spnego_key = cifs_get_spnego_key(ses, server);

fs/smb/client/smb2pdu.c

170

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

176

if (SERVER_IS_CHAN(server)) {

fs/smb/client/smb2pdu.c

1775

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

179

ses->server->hostname);

fs/smb/client/smb2pdu.c

1798

&blob_length, ses, server,

fs/smb/client/smb2pdu.c

182

chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/smb2pdu.c

1867

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

188

ses->chans[chan_index].server = NULL;

fs/smb/client/smb2pdu.c

1883

ses, server,

fs/smb/client/smb2pdu.c

189

server->terminate = true;

fs/smb/client/smb2pdu.c

1917

if (ses->server->dialect < SMB30_PROT_ID) {

fs/smb/client/smb2pdu.c

1945

struct TCP_Server_Info *server = sess_data->server;

fs/smb/client/smb2pdu.c

1947

type = smb2_select_sectype(server, ses->sectype);

fs/smb/client/smb2pdu.c

1971

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

1979

if (!server) {

fs/smb/client/smb2pdu.c

198

cifs_put_tcp_session(server, from_reconnect);

fs/smb/client/smb2pdu.c

1990

sess_data->server = server;

fs/smb/client/smb2pdu.c

200

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/smb2pdu.c

2002

memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,

fs/smb/client/smb2pdu.c

2022

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

203

pserver = server->primary_server;

fs/smb/client/smb2pdu.c

2031

if (!ses || !ses->server)

fs/smb/client/smb2pdu.c

2033

server = ses->server;

fs/smb/client/smb2pdu.c

2043

rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,

fs/smb/client/smb2pdu.c

2053

else if (server->sign)

fs/smb/client/smb2pdu.c

2065

rc = cifs_send_recv(xid, ses, ses->server,

fs/smb/client/smb2pdu.c

2107

struct TCP_Server_Info *server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

2111

if (!server || !tree)

fs/smb/client/smb2pdu.c

2128

rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,

fs/smb/client/smb2pdu.c

2153

if ((server->dialect == SMB311_PROT_ID) &&

fs/smb/client/smb2pdu.c

2165

if (server->credits >= server->max_credits)

fs/smb/client/smb2pdu.c

2169

min_t(int, server->max_credits -

fs/smb/client/smb2pdu.c

2170

server->credits, 64));

fs/smb/client/smb2pdu.c

2172

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

2212

!(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))

fs/smb/client/smb2pdu.c

2216

if (server->ops->validate_negotiate)

fs/smb/client/smb2pdu.c

2217

rc = server->ops->validate_negotiate(xid, tcon);

fs/smb/client/smb2pdu.c

2220

server->nosharesock = true;

fs/smb/client/smb2pdu.c

2240

struct TCP_Server_Info *server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

2249

if (!ses || !(ses->server))

fs/smb/client/smb2pdu.c

2263

rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, server,

fs/smb/client/smb2pdu.c

227

int smb3_update_ses_channels(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

2281

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

238

rc = cifs_chan_skip_or_disable(ses, server, from_reconnect, disable_mchan);

fs/smb/client/smb2pdu.c

2386

int smb2_parse_contexts(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

243

rc = cifs_chan_skip_or_disable(ses, server, from_reconnect, disable_mchan);

fs/smb/client/smb2pdu.c

2432

*oplock = server->ops->parse_lease_buf(cc, epoch,

fs/smb/client/smb2pdu.c

2466

add_lease_context(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

2477

iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock,

fs/smb/client/smb2pdu.c

2481

iov[num].iov_len = server->vals->create_lease_size;

fs/smb/client/smb2pdu.c

251

struct TCP_Server_Info *server, bool from_reconnect)

fs/smb/client/smb2pdu.c

2902

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

291

if (!ses->server || !server)

fs/smb/client/smb2pdu.c

2910

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

2919

if (!ses || !server) {

fs/smb/client/smb2pdu.c

2925

rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,

fs/smb/client/smb2pdu.c

294

spin_lock(&server->srv_lock);

fs/smb/client/smb2pdu.c

295

if (server->tcpStatus == CifsNeedReconnect) {

fs/smb/client/smb2pdu.c

3020

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

3024

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

3069

SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

308

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

3083

rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,

fs/smb/client/smb2pdu.c

314

if (server->terminate) {

fs/smb/client/smb2pdu.c

3144

if ((!server->oplocks) || (tcon->no_lease))

fs/smb/client/smb2pdu.c

3147

if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||

fs/smb/client/smb2pdu.c

315

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

3150

else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&

fs/smb/client/smb2pdu.c

3154

rc = add_lease_context(server, req, iov, &n_iov,

fs/smb/client/smb2pdu.c

318

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

321

rc = cifs_wait_for_server_reconnect(server, tcon->retry);

fs/smb/client/smb2pdu.c

326

if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {

fs/smb/client/smb2pdu.c

3260

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

3271

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

3275

if (!ses || !server)

fs/smb/client/smb2pdu.c

3286

rc = SMB2_open_init(tcon, server,

fs/smb/client/smb2pdu.c

3298

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

3301

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

3349

rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch,

fs/smb/client/smb2pdu.c

3363

SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

3375

rc = smb2_ioctl_req_init(opcode, tcon, server,

fs/smb/client/smb2pdu.c

340

spin_lock(&server->srv_lock);

fs/smb/client/smb2pdu.c

341

switch (server->tcpStatus) {

fs/smb/client/smb2pdu.c

343

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

347

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

3477

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

3495

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

3497

if (!server)

fs/smb/client/smb2pdu.c

3517

rc = SMB2_ioctl_init(tcon, server,

fs/smb/client/smb2pdu.c

3527

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

3530

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

355

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

363

if (!cifs_chan_needs_reconnect(ses, server) &&

fs/smb/client/smb2pdu.c

3636

SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

3645

rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,

fs/smb/client/smb2pdu.c

3677

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

3690

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

3694

if (!ses || !server)

fs/smb/client/smb2pdu.c

3710

rc = SMB2_close_init(tcon, server,

fs/smb/client/smb2pdu.c

3720

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

3723

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

377

rc = cifs_negotiate_protocol(0, ses, server);

fs/smb/client/smb2pdu.c

3827

SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

3843

rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,

fs/smb/client/smb2pdu.c

3888

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

389

!(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {

fs/smb/client/smb2pdu.c

390

rc = smb3_update_ses_channels(ses, server,

fs/smb/client/smb2pdu.c

3902

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

3904

if (!server)

fs/smb/client/smb2pdu.c

3915

rc = SMB2_query_info_init(tcon, server,

fs/smb/client/smb2pdu.c

3929

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

3932

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

398

rc = cifs_setup_session(0, ses, server, ses->local_nls);

fs/smb/client/smb2pdu.c

4022

struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

4031

rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server,

fs/smb/client/smb2pdu.c

4060

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

4073

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

4076

if (!ses || !server)

fs/smb/client/smb2pdu.c

4090

rc = SMB2_notify_init(xid, &rqst, tcon, server,

fs/smb/client/smb2pdu.c

4103

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

4106

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

4161

smb2_echo_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/smb2pdu.c

4169

credits.instance = server->reconnect_instance;

fs/smb/client/smb2pdu.c

4172

release_mid(server, mid);

fs/smb/client/smb2pdu.c

4173

add_credits(server, &credits, CIFS_ECHO_OP);

fs/smb/client/smb2pdu.c

4176

static void cifs_renegotiate_iosize(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

4181

if (server == NULL || tcon == NULL)

fs/smb/client/smb2pdu.c

4186

cifs_negotiate_iosize(server, cifs_sb->ctx, tcon);

fs/smb/client/smb2pdu.c

4192

struct TCP_Server_Info *server = container_of(work,

fs/smb/client/smb2pdu.c

4205

if (!server->srv_count) {

fs/smb/client/smb2pdu.c

4209

server->srv_count++;

fs/smb/client/smb2pdu.c

4213

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2pdu.c

4219

if (server->terminate) {

fs/smb/client/smb2pdu.c

4220

cifs_put_tcp_session(server, true);

fs/smb/client/smb2pdu.c

4266

if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {

fs/smb/client/smb2pdu.c

4276

rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);

fs/smb/client/smb2pdu.c

4278

cifs_renegotiate_iosize(server, tcon);

fs/smb/client/smb2pdu.c

4308

rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);

fs/smb/client/smb2pdu.c

4319

cifs_requeue_server_reconn(server);

fs/smb/client/smb2pdu.c

4323

cifs_put_tcp_session(server, true);

fs/smb/client/smb2pdu.c

4327

SMB2_echo(struct TCP_Server_Info *server)

fs/smb/client/smb2pdu.c

4336

cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);

fs/smb/client/smb2pdu.c

4338

spin_lock(&server->srv_lock);

fs/smb/client/smb2pdu.c

4339

if (server->ops->need_neg &&

fs/smb/client/smb2pdu.c

4340

server->ops->need_neg(server)) {

fs/smb/client/smb2pdu.c

4341

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

4343

cifs_queue_server_reconn(server);

fs/smb/client/smb2pdu.c

4346

spin_unlock(&server->srv_lock);

fs/smb/client/smb2pdu.c

4348

rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,

fs/smb/client/smb2pdu.c

4358

rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,

fs/smb/client/smb2pdu.c

4359

server, CIFS_ECHO_OP, NULL);

fs/smb/client/smb2pdu.c

4376

struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

4384

rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,

fs/smb/client/smb2pdu.c

4406

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

4415

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

4418

if (!ses || !(ses->server))

fs/smb/client/smb2pdu.c

4429

rc = SMB2_flush_init(xid, &rqst, tcon, server,

fs/smb/client/smb2pdu.c

4440

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

4443

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

445

(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL) &&

fs/smb/client/smb2pdu.c

446

server->ops->query_server_interfaces) {

fs/smb/client/smb2pdu.c

4468

struct TCP_Server_Info *server = io_parms->server;

fs/smb/client/smb2pdu.c

4472

if (!server || !tcon)

fs/smb/client/smb2pdu.c

4476

if (!server->rdma || !server->smbd_conn)

fs/smb/client/smb2pdu.c

4480

if (server->sign)

fs/smb/client/smb2pdu.c

4488

if (io_parms->length < server->rdma_readwrite_threshold)

fs/smb/client/smb2pdu.c

4507

struct TCP_Server_Info *server = io_parms->server;

fs/smb/client/smb2pdu.c

4509

rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,

fs/smb/client/smb2pdu.c

4514

if (server == NULL)

fs/smb/client/smb2pdu.c

4542

bool need_invalidate = server->dialect == SMB30_PROT_ID;

fs/smb/client/smb2pdu.c

4544

rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->subreq.io_iter,

fs/smb/client/smb2pdu.c

455

rc = server->ops->query_server_interfaces(xid, tcon, false);

fs/smb/client/smb2pdu.c

4593

smb2_readv_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/smb2pdu.c

4613

WARN_ONCE(rdata->server != server,

fs/smb/client/smb2pdu.c

4615

rdata->server, server);

fs/smb/client/smb2pdu.c

4624

credits.instance = server->reconnect_instance;

fs/smb/client/smb2pdu.c

4626

if (server->sign && !mid->decrypted) {

fs/smb/client/smb2pdu.c

4630

rc = smb2_verify_signature(&rqst, server);

fs/smb/client/smb2pdu.c

4657

if (server->sign && rdata->got_bytes)

fs/smb/client/smb2pdu.c

4667

credits.instance = server->reconnect_instance;

fs/smb/client/smb2pdu.c

4728

server->credits, server->in_flight,

fs/smb/client/smb2pdu.c

473

rc = smb3_update_ses_channels(ses, server,

fs/smb/client/smb2pdu.c

4735

release_mid(server, mid);

fs/smb/client/smb2pdu.c

4737

server->credits, server->in_flight,

fs/smb/client/smb2pdu.c

4739

add_credits(server, &credits, 0);

fs/smb/client/smb2pdu.c

4753

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

4761

if (!rdata->server)

fs/smb/client/smb2pdu.c

4762

rdata->server = cifs_pick_channel(tcon->ses);

fs/smb/client/smb2pdu.c

4765

io_parms.server = server = rdata->server;

fs/smb/client/smb2pdu.c

4791

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

4798

if (server->credits >= server->max_credits)

fs/smb/client/smb2pdu.c

4802

min_t(int, server->max_credits -

fs/smb/client/smb2pdu.c

4803

server->credits, credit_request));

fs/smb/client/smb2pdu.c

4805

rc = adjust_credits(server, rdata, cifs_trace_rw_credits_call_readv_adjust);

fs/smb/client/smb2pdu.c

4812

rc = cifs_call_async(server, &rqst,

fs/smb/client/smb2pdu.c

483

!SERVER_IS_CHAN(server)) {

fs/smb/client/smb2pdu.c

4857

if (!io_parms->server)

fs/smb/client/smb2pdu.c

4858

io_parms->server = cifs_pick_channel(io_parms->tcon->ses);

fs/smb/client/smb2pdu.c

487

smb3_update_ses_channels(ses, server, from_reconnect,

fs/smb/client/smb2pdu.c

4875

rc = cifs_send_recv(xid, ses, io_parms->server,

fs/smb/client/smb2pdu.c

4931

smb2_writev_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/smb2pdu.c

4947

WARN_ONCE(wdata->server != server,

fs/smb/client/smb2pdu.c

4949

wdata->server, server);

fs/smb/client/smb2pdu.c

4954

credits.instance = server->reconnect_instance;

fs/smb/client/smb2pdu.c

4955

result = smb2_check_receive(mid, server, 0);

fs/smb/client/smb2pdu.c

500

cifs_queue_server_reconn(server);

fs/smb/client/smb2pdu.c

5000

credits.instance = server->reconnect_instance;

fs/smb/client/smb2pdu.c

5043

server->credits, server->in_flight,

fs/smb/client/smb2pdu.c

5055

release_mid(server, mid);

fs/smb/client/smb2pdu.c

5057

server->credits, server->in_flight,

fs/smb/client/smb2pdu.c

5059

add_credits(server, &credits, 0);

fs/smb/client/smb2pdu.c

5070

struct TCP_Server_Info *server = wdata->server;

fs/smb/client/smb2pdu.c

5084

.server = server,

fs/smb/client/smb2pdu.c

5093

rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,

fs/smb/client/smb2pdu.c

5138

bool need_invalidate = server->dialect == SMB30_PROT_ID;

fs/smb/client/smb2pdu.c

5140

wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->subreq.io_iter,

fs/smb/client/smb2pdu.c

5176

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

5186

if (server->credits >= server->max_credits)

fs/smb/client/smb2pdu.c

5190

min_t(int, server->max_credits -

fs/smb/client/smb2pdu.c

5191

server->credits, credit_request));

fs/smb/client/smb2pdu.c

5193

rc = adjust_credits(server, wdata, cifs_trace_rw_credits_call_writev_adjust);

fs/smb/client/smb2pdu.c

5204

rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,

fs/smb/client/smb2pdu.c

5237

server->credits, server->in_flight,

fs/smb/client/smb2pdu.c

5240

add_credits_and_wake_if(wdata->server, &wdata->credits, 0);

fs/smb/client/smb2pdu.c

5263

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

5270

if (!io_parms->server)

fs/smb/client/smb2pdu.c

5271

io_parms->server = cifs_pick_channel(io_parms->tcon->ses);

fs/smb/client/smb2pdu.c

5272

server = io_parms->server;

fs/smb/client/smb2pdu.c

5273

if (server == NULL)

fs/smb/client/smb2pdu.c

5279

rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,

fs/smb/client/smb2pdu.c

529

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

5319

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

5322

rc = cifs_send_recv(xid, io_parms->tcon->ses, server,

fs/smb/client/smb2pdu.c

543

smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server);

fs/smb/client/smb2pdu.c

5504

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

5519

rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,

fs/smb/client/smb2pdu.c

555

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

5558

output_size = min_t(unsigned int, output_size, server->maxBuf);

fs/smb/client/smb2pdu.c

5669

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

5676

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

5678

if (!ses || !(ses->server))

fs/smb/client/smb2pdu.c

5689

rc = SMB2_query_directory_init(xid, tcon, server,

fs/smb/client/smb2pdu.c

5700

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

5703

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

573

fill_small_buf(smb2_command, tcon, server,

fs/smb/client/smb2pdu.c

5746

SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

5757

rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,

fs/smb/client/smb2pdu.c

5808

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

5815

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

5817

if (!ses || !server)

fs/smb/client/smb2pdu.c

5834

rc = SMB2_set_info_init(tcon, server,

fs/smb/client/smb2pdu.c

5847

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

5850

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

587

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

592

rc = smb2_reconnect(smb2_command, tcon, server, false);

fs/smb/client/smb2pdu.c

5921

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

5932

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

5935

rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,

fs/smb/client/smb2pdu.c

596

return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,

fs/smb/client/smb2pdu.c

5961

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

5964

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

601

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

6012

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

6022

if ((tcon->ses == NULL) || server == NULL)

fs/smb/client/smb2pdu.c

6025

rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,

fs/smb/client/smb2pdu.c

6061

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

6069

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

6071

rc = build_qfs_info_req(&iov, tcon, server,

fs/smb/client/smb2pdu.c

6089

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

6092

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

613

return __smb2_plain_req_init(SMB2_IOCTL, tcon, server,

fs/smb/client/smb2pdu.c

6130

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

6138

server = cifs_pick_channel(ses);

fs/smb/client/smb2pdu.c

6157

rc = build_qfs_info_req(&iov, tcon, server,

fs/smb/client/smb2pdu.c

616

return smb2_plain_req_init(SMB2_IOCTL, tcon, server,

fs/smb/client/smb2pdu.c

6174

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

6177

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

6236

struct TCP_Server_Info *server;

fs/smb/client/smb2pdu.c

6242

server = cifs_pick_channel(tcon->ses);

fs/smb/client/smb2pdu.c

6246

rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,

fs/smb/client/smb2pdu.c

6277

smb2_set_replay(server, &rqst);

fs/smb/client/smb2pdu.c

6280

rc = cifs_send_recv(xid, tcon->ses, server,

fs/smb/client/smb2pdu.c

6330

struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);

fs/smb/client/smb2pdu.c

6333

rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,

fs/smb/client/smb2pdu.c

6357

rc = cifs_send_recv(xid, ses, server,

fs/smb/client/smb2pdu.c

729

struct TCP_Server_Info *server, unsigned int *total_len)

fs/smb/client/smb2pdu.c

765

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2pdu.c

783

if (server->compression.requested) {

fs/smb/client/smb2pdu.c

827

static void decode_compress_ctx(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

833

server->compression.enabled = false;

fs/smb/client/smb2pdu.c

858

server->compression.alg = alg;

fs/smb/client/smb2pdu.c

859

server->compression.enabled = true;

fs/smb/client/smb2pdu.c

86

(tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))

fs/smb/client/smb2pdu.c

862

static int decode_encrypt_ctx(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

89

(tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))

fs/smb/client/smb2pdu.c

898

server->cipher_type = 0;

fs/smb/client/smb2pdu.c

899

server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION;

fs/smb/client/smb2pdu.c

909

server->cipher_type = ctxt->Ciphers[0];

fs/smb/client/smb2pdu.c

910

server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;

fs/smb/client/smb2pdu.c

914

static void decode_signing_ctx(struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

937

server->signing_negotiated = true;

fs/smb/client/smb2pdu.c

938

server->signing_algorithm = le16_to_cpu(pctxt->SigningAlgorithms[0]);

fs/smb/client/smb2pdu.c

940

server->signing_algorithm);

fs/smb/client/smb2pdu.c

945

struct TCP_Server_Info *server,

fs/smb/client/smb2pdu.c

97

struct TCP_Server_Info *server)

fs/smb/client/smb2pdu.c

985

rc = decode_encrypt_ctx(server,

fs/smb/client/smb2pdu.c

988

decode_compress_ctx(server,

fs/smb/client/smb2pdu.c

991

server->posix_ext_supported = true;

fs/smb/client/smb2pdu.c

993

decode_signing_ctx(server,

fs/smb/client/smb2proto.h

111

int smb3_crypto_aead_allocate(struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

112

unsigned long smb_rqst_len(struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

116

void smb2_set_replay(struct TCP_Server_Info *server, struct smb_rqst *rqst);

fs/smb/client/smb2proto.h

125

struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

127

struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

137

int SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

145

int SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

160

int SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

167

struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

174

struct TCP_Server_Info *server, struct smb_rqst *rqst,

fs/smb/client/smb2proto.h

190

int SMB2_echo(struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

195

struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

202

int SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

221

struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

240

enum securityEnum smb2_select_sectype(struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

242

int smb2_parse_contexts(struct TCP_Server_Info *server, struct kvec *rsp_iov,

fs/smb/client/smb2proto.h

255

int smb3_crypto_shash_allocate(struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

257

struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

28

struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

35

struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

36

int smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

39

struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

41

struct mid_q_entry *smb2_setup_async_request(struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

43

struct cifs_tcon *smb2_find_smb_tcon(struct TCP_Server_Info *server,

fs/smb/client/smb2proto.h

46

bool smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server);

fs/smb/client/smb2proto.h

47

int smb3_handle_read_data(struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

109

smb2_find_smb_ses_unlocked(struct TCP_Server_Info *server, __u64 ses_id)

fs/smb/client/smb2transport.c

115

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2transport.c

134

static int smb2_get_sign_key(struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

140

if (SERVER_IS_CHAN(server))

fs/smb/client/smb2transport.c

141

server = server->primary_server;

fs/smb/client/smb2transport.c

144

list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {

fs/smb/client/smb2transport.c

194

smb2_find_smb_tcon(struct TCP_Server_Info *server, __u64 ses_id, __u32 tid)

fs/smb/client/smb2transport.c

200

ses = smb2_find_smb_ses_unlocked(server, ses_id);

fs/smb/client/smb2transport.c

214

smb2_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

226

rc = smb2_get_sign_key(server, sid, key);

fs/smb/client/smb2transport.c

253

&drqst, server, smb2_signature,

fs/smb/client/smb2transport.c

270

struct TCP_Server_Info *server = ses->server;

fs/smb/client/smb2transport.c

276

rc = smb3_crypto_shash_allocate(server);

fs/smb/client/smb2transport.c

289

if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||

fs/smb/client/smb2transport.c

290

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {

fs/smb/client/smb2transport.c

314

struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

32

smb3_crypto_shash_allocate(struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

323

is_binding = (cifs_chan_needs_reconnect(ses, server) &&

fs/smb/client/smb2transport.c

326

chan_index = cifs_ses_get_chan_index(ses, server);

fs/smb/client/smb2transport.c

34

struct cifs_secmech *p = &server->secmech;

fs/smb/client/smb2transport.c

390

cifs_dbg(VFS, "Cipher type %d\n", server->cipher_type);

fs/smb/client/smb2transport.c

395

if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||

fs/smb/client/smb2transport.c

396

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {

fs/smb/client/smb2transport.c

40

int smb3_get_sign_key(__u64 ses_id, struct TCP_Server_Info *server, u8 *key)

fs/smb/client/smb2transport.c

413

struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

437

return generate_smb3signingkey(ses, server, &triplet);

fs/smb/client/smb2transport.c

442

struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

466

return generate_smb3signingkey(ses, server, &triplet);

fs/smb/client/smb2transport.c

470

smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

481

if (server->vals->protocol_id <= SMB21_PROT_ID)

fs/smb/client/smb2transport.c

482

return smb2_calc_signature(rqst, server, allocate_crypto);

fs/smb/client/smb2transport.c

484

rc = smb3_get_sign_key(le64_to_cpu(shdr->SessionId), server, key);

fs/smb/client/smb2transport.c

495

shash = server->secmech.aes_cmac;

fs/smb/client/smb2transport.c

52

pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;

fs/smb/client/smb2transport.c

539

&drqst, server, smb3_signature,

fs/smb/client/smb2transport.c

552

smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

568

spin_lock(&server->srv_lock);

fs/smb/client/smb2transport.c

569

if (server->ops->need_neg &&

fs/smb/client/smb2transport.c

570

server->ops->need_neg(server)) {

fs/smb/client/smb2transport.c

571

spin_unlock(&server->srv_lock);

fs/smb/client/smb2transport.c

574

spin_unlock(&server->srv_lock);

fs/smb/client/smb2transport.c

575

if (!is_binding && !server->session_estab) {

fs/smb/client/smb2transport.c

580

return smb3_calc_signature(rqst, server, false);

fs/smb/client/smb2transport.c

584

smb2_verify_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

594

server->ignore_signature ||

fs/smb/client/smb2transport.c

595

(!server->session_estab))

fs/smb/client/smb2transport.c

616

rc = smb3_calc_signature(rqst, server, true);

fs/smb/client/smb2transport.c

635

smb2_seq_num_into_buf(struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

640

shdr->MessageId = get_next_mid64(server);

fs/smb/client/smb2transport.c

643

get_next_mid(server);

fs/smb/client/smb2transport.c

648

struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

653

if (server == NULL) {

fs/smb/client/smb2transport.c

68

is_binding = (cifs_chan_needs_reconnect(ses, server) &&

fs/smb/client/smb2transport.c

686

smb2_get_mid_entry(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

689

switch (READ_ONCE(server->tcpStatus)) {

fs/smb/client/smb2transport.c

719

*mid = smb2_mid_entry_alloc(shdr, server);

fs/smb/client/smb2transport.c

722

spin_lock(&server->mid_queue_lock);

fs/smb/client/smb2transport.c

723

list_add_tail(&(*mid)->qhead, &server->pending_mid_q);

fs/smb/client/smb2transport.c

724

spin_unlock(&server->mid_queue_lock);

fs/smb/client/smb2transport.c

730

smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

743

if (len > 24 && server->sign && !mid->decrypted) {

fs/smb/client/smb2transport.c

746

rc = smb2_verify_signature(&rqst, server);

fs/smb/client/smb2transport.c

756

smb2_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,

fs/smb/client/smb2transport.c

764

smb2_seq_num_into_buf(server, shdr);

fs/smb/client/smb2transport.c

766

rc = smb2_get_mid_entry(ses, server, shdr, &mid);

fs/smb/client/smb2transport.c

768

revert_current_mid_from_hdr(server, shdr);

fs/smb/client/smb2transport.c

772

rc = smb2_sign_rqst(rqst, server);

fs/smb/client/smb2transport.c

774

revert_current_mid_from_hdr(server, shdr);

fs/smb/client/smb2transport.c

775

delete_mid(server, mid);

fs/smb/client/smb2transport.c

783

smb2_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)

fs/smb/client/smb2transport.c

790

spin_lock(&server->srv_lock);

fs/smb/client/smb2transport.c

791

if (server->tcpStatus == CifsNeedNegotiate &&

fs/smb/client/smb2transport.c

793

spin_unlock(&server->srv_lock);

fs/smb/client/smb2transport.c

796

spin_unlock(&server->srv_lock);

fs/smb/client/smb2transport.c

798

smb2_seq_num_into_buf(server, shdr);

fs/smb/client/smb2transport.c

800

mid = smb2_mid_entry_alloc(shdr, server);

fs/smb/client/smb2transport.c

802

revert_current_mid_from_hdr(server, shdr);

fs/smb/client/smb2transport.c

806

rc = smb2_sign_rqst(rqst, server);

fs/smb/client/smb2transport.c

808

revert_current_mid_from_hdr(server, shdr);

fs/smb/client/smb2transport.c

809

release_mid(server, mid);

fs/smb/client/smb2transport.c

817

smb3_crypto_aead_allocate(struct TCP_Server_Info *server)

fs/smb/client/smb2transport.c

821

if (!server->secmech.enc) {

fs/smb/client/smb2transport.c

822

if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||

fs/smb/client/smb2transport.c

823

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))

fs/smb/client/smb2transport.c

832

server->secmech.enc = tfm;

fs/smb/client/smb2transport.c

835

if (!server->secmech.dec) {

fs/smb/client/smb2transport.c

836

if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||

fs/smb/client/smb2transport.c

837

(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))

fs/smb/client/smb2transport.c

842

crypto_free_aead(server->secmech.enc);

fs/smb/client/smb2transport.c

843

server->secmech.enc = NULL;

fs/smb/client/smb2transport.c

848

server->secmech.dec = tfm;

fs/smb/client/smb2transport.c

88

if (chan->server == server) {

fs/smb/client/smbdirect.c

1884

void smbd_destroy(struct TCP_Server_Info *server)

fs/smb/client/smbdirect.c

1886

struct smbd_connection *info = server->smbd_conn;

fs/smb/client/smbdirect.c

1970

server->smbd_conn = NULL;

fs/smb/client/smbdirect.c

1977

int smbd_reconnect(struct TCP_Server_Info *server)

fs/smb/client/smbdirect.c

1981

if (!server->smbd_conn) {

fs/smb/client/smbdirect.c

1990

if (server->smbd_conn->socket.status == SMBDIRECT_SOCKET_CONNECTED) {

fs/smb/client/smbdirect.c

1992

smbd_destroy(server);

fs/smb/client/smbdirect.c

1997

server->smbd_conn = smbd_get_connection(

fs/smb/client/smbdirect.c

1998

server, (struct sockaddr *) &server->dstaddr);

fs/smb/client/smbdirect.c

2000

if (server->smbd_conn) {

fs/smb/client/smbdirect.c

2002

trace_smb3_smbd_connect_done(server->hostname, server->conn_id, &server->dstaddr);

fs/smb/client/smbdirect.c

2005

trace_smb3_smbd_connect_err(server->hostname, server->conn_id, &server->dstaddr);

fs/smb/client/smbdirect.c

2086

struct TCP_Server_Info *server, struct sockaddr *dstaddr, int port)

fs/smb/client/smbdirect.c

2303

server->smbd_conn = info;

fs/smb/client/smbdirect.c

2304

smbd_destroy(server);

fs/smb/client/smbdirect.c

2340

struct TCP_Server_Info *server, struct sockaddr *dstaddr)

fs/smb/client/smbdirect.c

2347

ret = _smbd_get_connection(server, dstaddr, port);

fs/smb/client/smbdirect.c

2359

server->rdma_readwrite_threshold =

fs/smb/client/smbdirect.c

2523

int smbd_send(struct TCP_Server_Info *server,

fs/smb/client/smbdirect.c

2526

struct smbd_connection *info = server->smbd_conn;

fs/smb/client/smbdirect.c

2546

remaining_data_length += smb_rqst_len(server, &rqst_array[i]);

fs/smb/client/smbdirect.c

2564

rqst_idx, smb_rqst_len(server, rqst));

fs/smb/client/smbdirect.c

2570

iov_iter_count(&rqst->rq_iter), smb_rqst_len(server, rqst));

fs/smb/client/smbdirect.h

11

#define cifs_rdma_enabled(server) ((server)->rdma)

fs/smb/client/smbdirect.h

45

struct TCP_Server_Info *server, struct sockaddr *dstaddr);

fs/smb/client/smbdirect.h

50

int smbd_reconnect(struct TCP_Server_Info *server);

fs/smb/client/smbdirect.h

52

void smbd_destroy(struct TCP_Server_Info *server);

fs/smb/client/smbdirect.h

56

int smbd_send(struct TCP_Server_Info *server,

fs/smb/client/smbdirect.h

66

#define cifs_rdma_enabled(server) 0

fs/smb/client/smbdirect.h

69

struct TCP_Server_Info *server, struct sockaddr *dstaddr) {return NULL;}

fs/smb/client/smbdirect.h

70

static inline int smbd_reconnect(struct TCP_Server_Info *server) {return -1; }

fs/smb/client/smbdirect.h

71

static inline void smbd_destroy(struct TCP_Server_Info *server) {}

fs/smb/client/smbdirect.h

73

static inline int smbd_send(struct TCP_Server_Info *server, int num_rqst, struct smb_rqst *rqst) {return -1; }

fs/smb/client/trace.h

1699

TP_PROTO(struct TCP_Server_Info *server,

fs/smb/client/trace.h

1702

TP_ARGS(server, ses, rc),

fs/smb/client/trace.h

1707

__string(host, server->hostname)

fs/smb/client/trace.h

1720

memcpy(__entry->addr, &server->dstaddr, sizeof(__entry->addr));

fs/smb/client/trace.h

1722

if (server->sec_kerberos)

fs/smb/client/trace.h

1724

else if (server->sec_mskerberos)

fs/smb/client/trace.h

1726

else if (server->sec_iakerb)

fs/smb/client/transport.c

1001

cifs_server_lock(server);

fs/smb/client/transport.c

1002

smb311_update_preauth_hash(ses, server, rqst[0].rq_iov, rqst[0].rq_nvec);

fs/smb/client/transport.c

1003

cifs_server_unlock(server);

fs/smb/client/transport.c

1010

rc = wait_for_response(server, mid[i]);

fs/smb/client/transport.c

1018

send_cancel(ses, server, &rqst[i], mid[i], xid);

fs/smb/client/transport.c

1035

rc = cifs_sync_mid_result(mid[i], server);

fs/smb/client/transport.c

1049

rc = server->ops->check_receive(mid[i], server,

fs/smb/client/transport.c

1078

cifs_server_lock(server);

fs/smb/client/transport.c

1079

smb311_update_preauth_hash(ses, server, &iov, 1);

fs/smb/client/transport.c

1080

cifs_server_unlock(server);

fs/smb/client/transport.c

1094

delete_mid(server, mid[i]);

fs/smb/client/transport.c

1102

struct TCP_Server_Info *server,

fs/smb/client/transport.c

1106

return compound_send_recv(xid, ses, server, flags, 1,

fs/smb/client/transport.c

1116

cifs_discard_remaining_data(struct TCP_Server_Info *server)

fs/smb/client/transport.c

1118

unsigned int rfclen = server->pdu_size;

fs/smb/client/transport.c

1119

size_t remaining = rfclen - server->total_read;

fs/smb/client/transport.c

1124

length = cifs_discard_from_socket(server,

fs/smb/client/transport.c

1126

CIFSMaxBufSize + MAX_HEADER_SIZE(server)));

fs/smb/client/transport.c

1129

server->total_read += length;

fs/smb/client/transport.c

1137

__cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid,

fs/smb/client/transport.c

1142

length = cifs_discard_remaining_data(server);

fs/smb/client/transport.c

1143

dequeue_mid(server, mid, malformed);

fs/smb/client/transport.c

1144

mid->resp_buf = server->smallbuf;

fs/smb/client/transport.c

1145

server->smallbuf = NULL;

fs/smb/client/transport.c

1150

cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

1154

return __cifs_readv_discard(server, mid, rdata->result);

fs/smb/client/transport.c

1158

cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

1163

char *buf = server->smallbuf;

fs/smb/client/transport.c

1164

unsigned int buflen = server->pdu_size;

fs/smb/client/transport.c

1175

len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -

fs/smb/client/transport.c

1176

HEADER_SIZE(server) + 1;

fs/smb/client/transport.c

1178

length = cifs_read_from_socket(server,

fs/smb/client/transport.c

1179

buf + HEADER_SIZE(server) - 1, len);

fs/smb/client/transport.c

1182

server->total_read += length;

fs/smb/client/transport.c

1184

if (server->ops->is_session_expired &&

fs/smb/client/transport.c

1185

server->ops->is_session_expired(buf)) {

fs/smb/client/transport.c

1186

cifs_reconnect(server, true);

fs/smb/client/transport.c

119

delete_mid(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

1190

if (server->ops->is_status_pending &&

fs/smb/client/transport.c

1191

server->ops->is_status_pending(buf, server)) {

fs/smb/client/transport.c

1192

cifs_discard_remaining_data(server);

fs/smb/client/transport.c

1198

rdata->iov[0].iov_len = server->total_read;

fs/smb/client/transport.c

1203

rdata->result = server->ops->map_error(buf, false);

fs/smb/client/transport.c

1208

return __cifs_readv_discard(server, mid, false);

fs/smb/client/transport.c

121

spin_lock(&server->mid_queue_lock);

fs/smb/client/transport.c

1212

if (server->total_read < server->vals->read_rsp_size) {

fs/smb/client/transport.c

1214

__func__, server->total_read,

fs/smb/client/transport.c

1215

server->vals->read_rsp_size);

fs/smb/client/transport.c

1217

server->total_read, server->vals->read_rsp_size);

fs/smb/client/transport.c

1218

return cifs_readv_discard(server, mid);

fs/smb/client/transport.c

1221

data_offset = server->ops->read_data_offset(buf);

fs/smb/client/transport.c

1222

if (data_offset < server->total_read) {

fs/smb/client/transport.c

1230

data_offset = server->total_read;

fs/smb/client/transport.c

1237

return cifs_readv_discard(server, mid);

fs/smb/client/transport.c

1241

__func__, server->total_read, data_offset);

fs/smb/client/transport.c

1243

len = data_offset - server->total_read;

fs/smb/client/transport.c

1246

length = cifs_read_from_socket(server,

fs/smb/client/transport.c

1247

buf + server->total_read, len);

fs/smb/client/transport.c

1250

server->total_read += length;

fs/smb/client/transport.c

1251

rdata->iov[0].iov_len = server->total_read;

fs/smb/client/transport.c

1258

data_len = server->ops->read_data_length(buf, use_rdma_mr);

fs/smb/client/transport.c

1263

return cifs_readv_discard(server, mid);

fs/smb/client/transport.c

127

spin_unlock(&server->mid_queue_lock);

fs/smb/client/transport.c

1271

length = cifs_read_iter_from_socket(server, &rdata->subreq.io_iter,

fs/smb/client/transport.c

1275

server->total_read += length;

fs/smb/client/transport.c

1278

server->total_read, buflen, data_len);

fs/smb/client/transport.c

1281

if (server->total_read < buflen)

fs/smb/client/transport.c

1282

return cifs_readv_discard(server, mid);

fs/smb/client/transport.c

1284

dequeue_mid(server, mid, false);

fs/smb/client/transport.c

1285

mid->resp_buf = server->smallbuf;

fs/smb/client/transport.c

1286

server->smallbuf = NULL;

fs/smb/client/transport.c

129

release_mid(server, mid);

fs/smb/client/transport.c

142

smb_send_kvec(struct TCP_Server_Info *server, struct msghdr *smb_msg,

fs/smb/client/transport.c

147

struct socket *ssocket = server->ssocket;

fs/smb/client/transport.c

151

if (server->noblocksnd)

fs/smb/client/transport.c

186

(!server->noblocksnd && (retries > 2))) {

fs/smb/client/transport.c

214

smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst)

fs/smb/client/transport.c

221

if (!is_smb1(server) && rqst->rq_nvec >= 2 &&

fs/smb/client/transport.c

238

int __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,

fs/smb/client/transport.c

248

struct socket *ssocket = server->ssocket;

fs/smb/client/transport.c

252

cifs_in_send_inc(server);

fs/smb/client/transport.c

253

if (cifs_rdma_enabled(server)) {

fs/smb/client/transport.c

256

if (server->smbd_conn)

fs/smb/client/transport.c

257

rc = smbd_send(server, num_rqst, rqst);

fs/smb/client/transport.c

276

send_length += smb_rqst_len(server, &rqst[j]);

fs/smb/client/transport.c

296

rc = smb_send_kvec(server, &smb_msg, &sent);

fs/smb/client/transport.c

318

rc = smb_send_kvec(server, &smb_msg, &sent);

fs/smb/client/transport.c

326

rc = smb_send_kvec(server, &smb_msg, &sent);

fs/smb/client/transport.c

34

cifs_wake_up_task(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

363

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/transport.c

364

trace_smb3_partial_send_reconnect(server->current_mid,

fs/smb/client/transport.c

365

server->conn_id, server->hostname);

fs/smb/client/transport.c

377

cifs_signal_cifsd_for_reconnect(server, false);

fs/smb/client/transport.c

381

cifs_in_send_dec(server);

fs/smb/client/transport.c

386

smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,

fs/smb/client/transport.c

398

return smb_compress(server, &rqst[0], __smb_send_rqst);

fs/smb/client/transport.c

401

return __smb_send_rqst(server, num_rqst, rqst);

fs/smb/client/transport.c

406

if (!server->ops->init_transform_rq) {

fs/smb/client/transport.c

41

void __release_mid(struct TCP_Server_Info *server, struct mid_q_entry *midEntry)

fs/smb/client/transport.c

414

rc = server->ops->init_transform_rq(server, num_rqst + 1,

fs/smb/client/transport.c

417

rc = __smb_send_rqst(server, num_rqst + 1, new_rqst);

fs/smb/client/transport.c

424

wait_for_free_credits(struct TCP_Server_Info *server, const int num_credits,

fs/smb/client/transport.c

44

__le16 command = server->vals->lock_cmd;

fs/smb/client/transport.c

443

credits = server->ops->get_credits_field(server, optype);

fs/smb/client/transport.c

448

spin_lock(&server->req_lock);

fs/smb/client/transport.c

451

server->in_flight++;

fs/smb/client/transport.c

452

if (server->in_flight > server->max_in_flight)

fs/smb/client/transport.c

453

server->max_in_flight = server->in_flight;

fs/smb/client/transport.c

455

*instance = server->reconnect_instance;

fs/smb/client/transport.c

457

in_flight = server->in_flight;

fs/smb/client/transport.c

458

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

460

trace_smb3_nblk_credits(server->current_mid,

fs/smb/client/transport.c

461

server->conn_id, server->hostname, scredits, -1, in_flight);

fs/smb/client/transport.c

469

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

471

spin_lock(&server->srv_lock);

fs/smb/client/transport.c

472

if (server->tcpStatus == CifsExiting) {

fs/smb/client/transport.c

473

spin_unlock(&server->srv_lock);

fs/smb/client/transport.c

476

spin_unlock(&server->srv_lock);

fs/smb/client/transport.c

478

spin_lock(&server->req_lock);

fs/smb/client/transport.c

481

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

483

cifs_num_waiters_inc(server);

fs/smb/client/transport.c

484

rc = wait_event_killable_timeout(server->request_q,

fs/smb/client/transport.c

485

has_credits(server, credits, num_credits), t);

fs/smb/client/transport.c

486

cifs_num_waiters_dec(server);

fs/smb/client/transport.c

488

spin_lock(&server->req_lock);

fs/smb/client/transport.c

490

in_flight = server->in_flight;

fs/smb/client/transport.c

491

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

493

trace_smb3_credit_timeout(server->current_mid,

fs/smb/client/transport.c

494

server->conn_id, server->hostname, scredits,

fs/smb/client/transport.c

502

spin_lock(&server->req_lock);

fs/smb/client/transport.c

518

server->in_flight > 2 * MAX_COMPOUND &&

fs/smb/client/transport.c

520

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

522

cifs_num_waiters_inc(server);

fs/smb/client/transport.c

524

server->request_q,

fs/smb/client/transport.c

525

has_credits(server, credits,

fs/smb/client/transport.c

528

cifs_num_waiters_dec(server);

fs/smb/client/transport.c

53

server->ops->handle_cancelled_mid)

fs/smb/client/transport.c

530

spin_lock(&server->req_lock);

fs/smb/client/transport.c

532

in_flight = server->in_flight;

fs/smb/client/transport.c

533

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

536

server->current_mid,

fs/smb/client/transport.c

537

server->conn_id, server->hostname,

fs/smb/client/transport.c

54

server->ops->handle_cancelled_mid(midEntry, server);

fs/smb/client/transport.c

545

spin_lock(&server->req_lock);

fs/smb/client/transport.c

557

server->in_flight += num_credits;

fs/smb/client/transport.c

558

if (server->in_flight > server->max_in_flight)

fs/smb/client/transport.c

559

server->max_in_flight = server->in_flight;

fs/smb/client/transport.c

560

*instance = server->reconnect_instance;

fs/smb/client/transport.c

563

in_flight = server->in_flight;

fs/smb/client/transport.c

564

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

566

trace_smb3_waitff_credits(server->current_mid,

fs/smb/client/transport.c

567

server->conn_id, server->hostname, scredits,

fs/smb/client/transport.c

577

int wait_for_free_request(struct TCP_Server_Info *server, const int flags,

fs/smb/client/transport.c

580

return wait_for_free_credits(server, 1, -1, flags,

fs/smb/client/transport.c

585

wait_for_compound_request(struct TCP_Server_Info *server, int num,

fs/smb/client/transport.c

591

credits = server->ops->get_credits_field(server, flags & CIFS_OP_MASK);

fs/smb/client/transport.c

593

spin_lock(&server->req_lock);

fs/smb/client/transport.c

595

in_flight = server->in_flight;

fs/smb/client/transport.c

614

if (server->in_flight == 0) {

fs/smb/client/transport.c

615

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

616

trace_smb3_insufficient_credits(server->current_mid,

fs/smb/client/transport.c

617

server->conn_id, server->hostname, scredits,

fs/smb/client/transport.c

624

spin_unlock(&server->req_lock);

fs/smb/client/transport.c

626

return wait_for_free_credits(server, num, 60000, flags,

fs/smb/client/transport.c

631

cifs_wait_mtu_credits(struct TCP_Server_Info *server, size_t size,

fs/smb/client/transport.c

636

credits->instance = server->reconnect_instance;

fs/smb/client/transport.c

640

int wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

648

error = wait_event_state(server->response_q,

fs/smb/client/transport.c

663

cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,

fs/smb/client/transport.c

677

rc = wait_for_free_request(server, flags, &instance);

fs/smb/client/transport.c

685

cifs_server_lock(server);

fs/smb/client/transport.c

69

if (atomic_read(&server->num_cmds[smb_cmd]) == 0) {

fs/smb/client/transport.c

692

if (instance != server->reconnect_instance) {

fs/smb/client/transport.c

693

cifs_server_unlock(server);

fs/smb/client/transport.c

694

add_credits_and_wake_if(server, &credits, optype);

fs/smb/client/transport.c

698

mid = server->ops->setup_async_request(server, rqst);

fs/smb/client/transport.c

70

server->slowest_cmd[smb_cmd] = roundtrip_time;

fs/smb/client/transport.c

700

cifs_server_unlock(server);

fs/smb/client/transport.c

701

add_credits_and_wake_if(server, &credits, optype);

fs/smb/client/transport.c

71

server->fastest_cmd[smb_cmd] = roundtrip_time;

fs/smb/client/transport.c

713

spin_lock(&server->mid_queue_lock);

fs/smb/client/transport.c

714

list_add_tail(&mid->qhead, &server->pending_mid_q);

fs/smb/client/transport.c

715

spin_unlock(&server->mid_queue_lock);

fs/smb/client/transport.c

722

rc = smb_send_rqst(server, 1, rqst, flags);

fs/smb/client/transport.c

725

revert_current_mid(server, mid->credits);

fs/smb/client/transport.c

726

server->sequence_number -= 2;

fs/smb/client/transport.c

727

delete_mid(server, mid);

fs/smb/client/transport.c

73

if (server->slowest_cmd[smb_cmd] < roundtrip_time)

fs/smb/client/transport.c

730

cifs_server_unlock(server);

fs/smb/client/transport.c

735

add_credits_and_wake_if(server, &credits, optype);

fs/smb/client/transport.c

739

int cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)

fs/smb/client/transport.c

74

server->slowest_cmd[smb_cmd] = roundtrip_time;

fs/smb/client/transport.c

746

spin_lock(&server->mid_queue_lock);

fs/smb/client/transport.c

749

spin_unlock(&server->mid_queue_lock);

fs/smb/client/transport.c

75

else if (server->fastest_cmd[smb_cmd] > roundtrip_time)

fs/smb/client/transport.c

76

server->fastest_cmd[smb_cmd] = roundtrip_time;

fs/smb/client/transport.c

768

spin_unlock(&server->mid_queue_lock);

fs/smb/client/transport.c

774

spin_unlock(&server->mid_queue_lock);

fs/smb/client/transport.c

777

release_mid(server, mid);

fs/smb/client/transport.c

78

cifs_stats_inc(&server->num_cmds[smb_cmd]);

fs/smb/client/transport.c

782

cifs_compound_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

785

.value = server->ops->get_credits(mid),

fs/smb/client/transport.c

786

.instance = server->reconnect_instance,

fs/smb/client/transport.c

789

add_credits(server, &credits, mid->optype);

fs/smb/client/transport.c

79

server->time_per_cmd[smb_cmd] += roundtrip_time;

fs/smb/client/transport.c

796

cifs_compound_last_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

798

cifs_compound_callback(server, mid);

fs/smb/client/transport.c

799

cifs_wake_up_task(server, mid);

fs/smb/client/transport.c

803

cifs_cancelled_callback(struct TCP_Server_Info *server, struct mid_q_entry *mid)

fs/smb/client/transport.c

805

cifs_compound_callback(server, mid);

fs/smb/client/transport.c

806

release_mid(server, mid);

fs/smb/client/transport.c

825

struct TCP_Server_Info *server = NULL;

fs/smb/client/transport.c

835

server = ses->chans[cur].server;

fs/smb/client/transport.c

836

if (!server || server->terminate)

fs/smb/client/transport.c

850

if (server->in_flight < min_in_flight) {

fs/smb/client/transport.c

851

min_in_flight = server->in_flight;

fs/smb/client/transport.c

856

server = ses->chans[index].server;

fs/smb/client/transport.c

859

return server;

fs/smb/client/transport.c

864

struct TCP_Server_Info *server,

fs/smb/client/transport.c

882

if (!ses || !ses->server || !server) {

fs/smb/client/transport.c

887

spin_lock(&server->srv_lock);

fs/smb/client/transport.c

888

if (server->tcpStatus == CifsExiting) {

fs/smb/client/transport.c

889

spin_unlock(&server->srv_lock);

fs/smb/client/transport.c

892

spin_unlock(&server->srv_lock);

fs/smb/client/transport.c

902

rc = wait_for_compound_request(server, num_rqst, flags,

fs/smb/client/transport.c

918

cifs_server_lock(server);

fs/smb/client/transport.c

927

if (instance != server->reconnect_instance) {

fs/smb/client/transport.c

928

cifs_server_unlock(server);

fs/smb/client/transport.c

930

add_credits(server, &credits[j], optype);

fs/smb/client/transport.c

935

mid[i] = server->ops->setup_request(ses, server, &rqst[i]);

fs/smb/client/transport.c

937

revert_current_mid(server, i);

fs/smb/client/transport.c

939

delete_mid(server, mid[j]);

fs/smb/client/transport.c

940

cifs_server_unlock(server);

fs/smb/client/transport.c

944

add_credits(server, &credits[j], optype);

fs/smb/client/transport.c

961

rc = smb_send_rqst(server, num_rqst, rqst, flags);

fs/smb/client/transport.c

967

revert_current_mid(server, num_rqst);

fs/smb/client/transport.c

968

server->sequence_number -= 2;

fs/smb/client/transport.c

971

cifs_server_unlock(server);

fs/smb/client/transport.c

979

add_credits(server, &credits[i], optype);

fs/smb/client/transport.c

99

cifs_stats_inc(&server->smb2slowcmd[smb_cmd]);

fs/smb/client/xattr.c

155

if (pTcon->ses->server->ops->set_EA) {

fs/smb/client/xattr.c

156

rc = pTcon->ses->server->ops->set_EA(xid, pTcon,

fs/smb/client/xattr.c

178

if (pTcon->ses->server->ops->set_acl) {

fs/smb/client/xattr.c

205

rc = pTcon->ses->server->ops->set_acl(pacl,

fs/smb/client/xattr.c

315

if (pTcon->ses->server->ops->query_all_EAs)

fs/smb/client/xattr.c

316

rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,

fs/smb/client/xattr.c

332

if (pTcon->ses->server->ops->get_acl == NULL)

fs/smb/client/xattr.c

353

pacl = pTcon->ses->server->ops->get_acl(cifs_sb,

fs/smb/client/xattr.c

424

if (pTcon->ses->server->ops->query_all_EAs)

fs/smb/client/xattr.c

425

rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,

fs/smb/client/xattr.c

60

if (pTcon->ses->server->ops->set_file_info)

fs/smb/client/xattr.c

61

rc = pTcon->ses->server->ops->set_file_info(inode, full_path,

fs/smb/client/xattr.c

84

if (pTcon->ses->server->ops->set_file_info)

fs/smb/client/xattr.c

85

rc = pTcon->ses->server->ops->set_file_info(inode, full_path,

include/linux/nfs_fs.h

481

extern struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server);

include/linux/nfs_xdr.h

1045

const struct nfs_server * server;

include/linux/nfs_xdr.h

1065

const struct nfs_server * server;

include/linux/nfs_xdr.h

1075

const struct nfs_server * server;

include/linux/nfs_xdr.h

1106

const struct nfs_server * server;

include/linux/nfs_xdr.h

1121

const struct nfs_server * server;

include/linux/nfs_xdr.h

1136

const struct nfs_server * server;

include/linux/nfs_xdr.h

1149

const struct nfs_server *server;

include/linux/nfs_xdr.h

1270

const struct nfs_server *server;

include/linux/nfs_xdr.h

1577

const struct nfs_server *server;

include/linux/nfs_xdr.h

315

const struct nfs_server *server;

include/linux/nfs_xdr.h

448

const struct nfs_server *server;

include/linux/nfs_xdr.h

494

const struct nfs_server *server; /* Needed for ID mapping */

include/linux/nfs_xdr.h

512

const struct nfs_server *server;

include/linux/nfs_xdr.h

559

const struct nfs_server *server;

include/linux/nfs_xdr.h

649

struct nfs_server *server;

include/linux/nfs_xdr.h

704

const struct nfs_server *server; /* used by write */

include/linux/nfs_xdr.h

725

const struct nfs_server *server;

include/linux/nfs_xdr.h

739

struct nfs_server *server;

include/linux/nfs_xdr.h

757

struct nfs_server *server;

include/linux/nfs_xdr.h

783

struct nfs_server * server;

include/linux/nfs_xdr.h

826

const struct nfs_server * server; /* Needed for name mapping */

include/linux/nfs_xdr.h

872

const struct nfs_server * server;

include/trace/events/afs.h

1541

__field(unsigned int, server)

include/trace/events/afs.h

1548

__entry->server = server_debug_id;

include/trace/events/afs.h

1555

__entry->server,

include/trace/events/afs.h

1646

__field(unsigned int, server)

include/trace/events/afs.h

1654

__entry->server = server_debug_id;

include/trace/events/afs.h

1661

__entry->server,

include/trace/events/afs.h

1668

TP_PROTO(struct afs_server *server, bool tx, struct afs_endpoint_state *estate,

include/trace/events/afs.h

1671

TP_ARGS(server, tx, estate, addr_index, error, abort_code, rtt_us),

include/trace/events/afs.h

1674

__field(unsigned int, server)

include/trace/events/afs.h

1686

__entry->server = server->debug_id;

include/trace/events/afs.h

1698

__entry->server, __entry->tx ? "tx" : "rx", __entry->estate,

include/trace/events/afs.h

1704

TP_PROTO(struct afs_vlserver *server, bool tx, struct afs_addr_list *alist,

include/trace/events/afs.h

1707

TP_ARGS(server, tx, alist, addr_index, error, abort_code, rtt_us),

include/trace/events/afs.h

1710

__field(unsigned int, server)

include/trace/events/afs.h

1721

__entry->server = server->debug_id;

include/trace/events/afs.h

1732

__entry->server, __entry->tx ? "tx" : "rx", __entry->addr_index,

include/trace/events/sunrpc.h

1716

__sockaddr(server, (r)->rq_xprt->xpt_locallen) \

include/trace/events/sunrpc.h

1724

__assign_sockaddr(server, &xprt->xpt_local, \

include/trace/events/sunrpc.h

1736

__entry->xid, __get_sockaddr(server), __get_sockaddr(client)

include/trace/events/sunrpc.h

180

__string(server, xprt->servername)

include/trace/events/sunrpc.h

190

__assign_str(server);

include/trace/events/sunrpc.h

198

__get_str(program), __get_str(server),

include/trace/events/sunrpc.h

1984

__sockaddr(server, (x)->xpt_locallen) \

include/trace/events/sunrpc.h

1991

__assign_sockaddr(server, &(x)->xpt_local, \

include/trace/events/sunrpc.h

2003

__get_sockaddr(server), __get_sockaddr(client), \

include/trace/events/sunrpc.h

2019

__assign_sockaddr(server, &xprt->xpt_local,

include/trace/events/sunrpc.h

207

const char *server,

include/trace/events/sunrpc.h

211

TP_ARGS(program, server, error),

include/trace/events/sunrpc.h

216

__string(server, server)

include/trace/events/sunrpc.h

222

__assign_str(server);

include/trace/events/sunrpc.h

226

__get_str(program), __get_str(server), __entry->error)

include/uapi/linux/qrtr.h

40

} server;

kernel/sched/debug.c

338

void *server)

kernel/sched/debug.c

341

struct sched_dl_entity *dl_se = (struct sched_dl_entity *)server;

kernel/sched/debug.c

386

server == &rq->fair_server ? "Fair" : "Ext",

kernel/sched/debug.c

397

void *server)

kernel/sched/debug.c

399

struct sched_dl_entity *dl_se = (struct sched_dl_entity *)server;

net/qrtr/af_qrtr.c

520

qrtr_node_assign(node, le32_to_cpu(pkt->server.node));

net/qrtr/ns.c

124

pkt.server.service = cpu_to_le32(srv->service);

net/qrtr/ns.c

125

pkt.server.instance = cpu_to_le32(srv->instance);

net/qrtr/ns.c

126

pkt.server.node = cpu_to_le32(srv->node);

net/qrtr/ns.c

127

pkt.server.port = cpu_to_le32(srv->port);

net/qrtr/ns.c

151

pkt.server.service = cpu_to_le32(srv->service);

net/qrtr/ns.c

152

pkt.server.instance = cpu_to_le32(srv->instance);

net/qrtr/ns.c

153

pkt.server.node = cpu_to_le32(srv->node);

net/qrtr/ns.c

154

pkt.server.port = cpu_to_le32(srv->port);

net/qrtr/ns.c

181

pkt.server.service = cpu_to_le32(srv->service);

net/qrtr/ns.c

182

pkt.server.instance = cpu_to_le32(srv->instance);

net/qrtr/ns.c

183

pkt.server.node = cpu_to_le32(srv->node);

net/qrtr/ns.c

184

pkt.server.port = cpu_to_le32(srv->port);

net/qrtr/ns.c

644

le32_to_cpu(pkt->server.service),

net/qrtr/ns.c

645

le32_to_cpu(pkt->server.instance),

net/qrtr/ns.c

646

le32_to_cpu(pkt->server.node),

net/qrtr/ns.c

647

le32_to_cpu(pkt->server.port));

net/qrtr/ns.c

651

le32_to_cpu(pkt->server.service),

net/qrtr/ns.c

652

le32_to_cpu(pkt->server.instance),

net/qrtr/ns.c

653

le32_to_cpu(pkt->server.node),

net/qrtr/ns.c

654

le32_to_cpu(pkt->server.port));

net/qrtr/ns.c

662

le32_to_cpu(pkt->server.service),

net/qrtr/ns.c

663

le32_to_cpu(pkt->server.instance));

net/qrtr/ns.c

667

le32_to_cpu(pkt->server.service),

net/qrtr/ns.c

668

le32_to_cpu(pkt->server.instance));

net/tipc/topsrv.c

127

struct tipc_topsrv *s = con->server;

net/tipc/topsrv.c

208

con->server = s;

net/tipc/topsrv.c

233

struct tipc_net *tn = tipc_net(con->server->net);

net/tipc/topsrv.c

252

struct tipc_topsrv *srv = con->server;

net/tipc/topsrv.c

355

if (!queue_work(con->server->send_wq, &con->swork))

net/tipc/topsrv.c

390

struct tipc_topsrv *srv = con->server;

net/tipc/topsrv.c

449

if (!queue_work(con->server->rcv_wq, &con->rwork))

net/tipc/topsrv.c

98

struct tipc_topsrv *server;

security/landlock/task.c

180

const struct landlock_ruleset *const server,

security/landlock/task.c

198

server_layer = server ? (server->num_layers - 1) : -1;

security/landlock/task.c

199

server_walker = server ? server->hierarchy : NULL;

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

27

int *server, int *conn,

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

34

*server = start_server_addr(type, addr, len, NULL);

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

35

if (*server < 0)

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

38

if (CHECK_FAIL(getsockname(*server, (struct sockaddr *)&ss, &slen)))

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

62

close(*server);

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

63

*server = -1;

tools/testing/selftests/bpf/prog_tests/sk_assign.c

236

__s64 server = -1;

tools/testing/selftests/bpf/prog_tests/sk_assign.c

268

server = start_server_addr(test->type,

tools/testing/selftests/bpf/prog_tests/sk_assign.c

271

if (server == -1)

tools/testing/selftests/bpf/prog_tests/sk_assign.c

274

err = bpf_map_update_elem(server_map, &zero, &server, BPF_ANY);

tools/testing/selftests/bpf/prog_tests/sk_assign.c

283

if (run_test(server, addr, test->len, test->type))

tools/testing/selftests/bpf/prog_tests/sk_assign.c

286

close(server);

tools/testing/selftests/bpf/prog_tests/sk_assign.c

287

server = -1;

tools/testing/selftests/bpf/prog_tests/sk_assign.c

291

close(server);

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

29

int server, i, err = 0;

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

31

server = start_server(test_case->family, test_case->type, NULL, 0, 0);

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

32

if (!ASSERT_GE(server, 0, "start_server_str"))

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

33

return server;

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

37

sk[i] = connect_to_fd(server, 0);

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

44

sk[i + 1] = accept(server, NULL, NULL);

tools/testing/selftests/bpf/prog_tests/sk_bypass_prot_mem.c

52

close(server);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

73

enum server accept_on;

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

100

client = connect_to_fd(server, 0);

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

104

child = accept(server, NULL, 0);

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

115

close(server);

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

94

int server, client, child;

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

96

server = start_server(test_case->family, test_case->type, test_case->addr, 0, 0);

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c

97

if (!ASSERT_NEQ(server, -1, "start_server"))

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

276

int server, client;

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

278

server = start_server_str(AF_INET, SOCK_STREAM, dst, port, NULL);

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

279

if (!ASSERT_OK_FD(server, "start service_1"))

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

286

client = connect_to_fd_opts(server, &opts);

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

292

close(server);

tools/testing/selftests/bpf/xdping.c

103

int server = 0;

tools/testing/selftests/bpf/xdping.c

131

server = 1;

tools/testing/selftests/bpf/xdping.c

146

if (!server && optind == argc) {

tools/testing/selftests/bpf/xdping.c

157

if (!server) {

tools/testing/selftests/bpf/xdping.c

179

server ? "xdping_server" : "xdping_client");

tools/testing/selftests/bpf/xdping.c

207

if (server) {

tools/testing/selftests/cgroup/test_memcontrol.c

1327

const char server[] = "localhost";

tools/testing/selftests/cgroup/test_memcontrol.c

1336

ret = getaddrinfo(server, servport, NULL, &ai);

tools/testing/selftests/drivers/net/napi_id_helper.c

25

int server;

tools/testing/selftests/drivers/net/napi_id_helper.c

43

server = socket(family, SOCK_STREAM, IPPROTO_TCP);

tools/testing/selftests/drivers/net/napi_id_helper.c

44

if (server < 0) {

tools/testing/selftests/drivers/net/napi_id_helper.c

52

if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {

tools/testing/selftests/drivers/net/napi_id_helper.c

61

if (bind(server, (struct sockaddr *)&address, addr_len) < 0) {

tools/testing/selftests/drivers/net/napi_id_helper.c

66

if (listen(server, 1) < 0) {

tools/testing/selftests/drivers/net/napi_id_helper.c

73

client = accept(server, NULL, 0);

tools/testing/selftests/drivers/net/napi_id_helper.c

97

close(server);

tools/testing/selftests/net/af_unix/scm_pidfd.c

315

int server;

tools/testing/selftests/net/af_unix/scm_pidfd.c

361

close(self->server);

tools/testing/selftests/net/af_unix/scm_pidfd.c

492

self->server = socket(AF_UNIX, variant->type, 0);

tools/testing/selftests/net/af_unix/scm_pidfd.c

493

ASSERT_NE(-1, self->server);

tools/testing/selftests/net/af_unix/scm_pidfd.c

497

err = bind(self->server, (struct sockaddr *)&self->server_addr.listen_addr, self->server_addr.addrlen);

tools/testing/selftests/net/af_unix/scm_pidfd.c

501

err = listen(self->server, 1);

tools/testing/selftests/net/af_unix/scm_pidfd.c

511

close(self->server);

tools/testing/selftests/net/af_unix/scm_pidfd.c

525

pfd = accept(self->server, NULL, NULL);

tools/testing/selftests/net/af_unix/scm_pidfd.c

528

pfd = self->server;

tools/testing/selftests/net/af_unix/unix_connect.c

109

close(self->server);

tools/testing/selftests/net/af_unix/unix_connect.c

124

self->server = socket(self->family, variant->type, 0);

tools/testing/selftests/net/af_unix/unix_connect.c

125

ASSERT_NE(-1, self->server);

tools/testing/selftests/net/af_unix/unix_connect.c

130

err = bind(self->server, (struct sockaddr *)&addr, addrlen);

tools/testing/selftests/net/af_unix/unix_connect.c

134

err = listen(self->server, 32);

tools/testing/selftests/net/af_unix/unix_connect.c

17

int server, client;

tools/testing/selftests/net/af_unix/unix_connreset.c

107

self->child = accept(self->server, NULL, NULL);

tools/testing/selftests/net/af_unix/unix_connreset.c

112

close(self->server);

tools/testing/selftests/net/af_unix/unix_connreset.c

137

close(self->server);

tools/testing/selftests/net/af_unix/unix_connreset.c

139

self->child = accept(self->server, NULL, NULL);

tools/testing/selftests/net/af_unix/unix_connreset.c

171

close(self->server);

tools/testing/selftests/net/af_unix/unix_connreset.c

34

int server;

tools/testing/selftests/net/af_unix/unix_connreset.c

69

self->server = socket(AF_UNIX, variant->socket_type, 0);

tools/testing/selftests/net/af_unix/unix_connreset.c

70

ASSERT_LT(-1, self->server);

tools/testing/selftests/net/af_unix/unix_connreset.c

72

err = bind(self->server, (struct sockaddr *)&addr, sizeof(addr));

tools/testing/selftests/net/af_unix/unix_connreset.c

77

err = listen(self->server, 1);

tools/testing/selftests/net/af_unix/unix_connreset.c

95

close(self->server);

tools/testing/selftests/net/fin_ack_lat.c

148

server(sock, laddr);

tools/testing/selftests/net/ipsec.c

629

struct sockaddr_in server;

tools/testing/selftests/net/ipsec.c

631

socklen_t s_len = sizeof(server);

tools/testing/selftests/net/ipsec.c

639

server.sin_family = AF_INET;

tools/testing/selftests/net/ipsec.c

640

server.sin_port = 0;

tools/testing/selftests/net/ipsec.c

641

memcpy(&server.sin_addr.s_addr, &listen_ip, sizeof(struct in_addr));

tools/testing/selftests/net/ipsec.c

643

if (bind(sock[0], (struct sockaddr *)&server, s_len)) {

tools/testing/selftests/net/ipsec.c

648

if (getsockname(sock[0], (struct sockaddr *)&server, &s_len)) {

tools/testing/selftests/net/ipsec.c

653

*server_port = ntohs(server.sin_port);

tools/testing/selftests/net/ipsec.c

676

struct sockaddr_in server;

tools/testing/selftests/net/ipsec.c

677

const struct sockaddr *dest_addr = (struct sockaddr *)&server;

tools/testing/selftests/net/ipsec.c

681

server.sin_family = AF_INET;

tools/testing/selftests/net/ipsec.c

682

server.sin_port = htons(port);

tools/testing/selftests/net/ipsec.c

683

server.sin_addr.s_addr = dest_ip;

tools/testing/selftests/net/ipsec.c

685

s_bytes = sendto(sock[1], buf, buf_len, 0, dest_addr, sizeof(server));

tools/testing/selftests/net/ipsec.c

690

printk("send part of the message: %zd/%zu", s_bytes, sizeof(server));

tools/testing/selftests/net/ipsec.c

713

struct sockaddr_in server;

tools/testing/selftests/net/ipsec.c

714

const struct sockaddr *dest_addr = (struct sockaddr *)&server;

tools/testing/selftests/net/ipsec.c

718

server.sin_family = AF_INET;

tools/testing/selftests/net/ipsec.c

719

server.sin_port = htons(port);

tools/testing/selftests/net/ipsec.c

720

server.sin_addr.s_addr = dest_ip;

tools/testing/selftests/net/ipsec.c

737

s_bytes = sendto(sock[1], buf, buf_len, 0, dest_addr, sizeof(server));

tools/testing/selftests/net/ipsec.c

742

printk("send part of the message: %zd/%zu", s_bytes, sizeof(server));

tools/testing/selftests/net/mptcp/mptcp_inq.c

587

ret = server(unixfds[1]);

tools/testing/selftests/net/mptcp/mptcp_sockopt.c

858

ret = server(pipefds[1]);

tools/testing/selftests/net/nettest.c

1336

static int msock_init(struct sock_args *args, int server)

tools/testing/selftests/net/nettest.c

1346

if (!server && args->has_local_ip)

tools/testing/selftests/net/nettest.c

1368

if (server) {

tools/testing/selftests/net/nettest.c

1389

if (server &&

tools/testing/selftests/net/so_incoming_cpu.c

244

int server;

tools/testing/selftests/net/so_incoming_cpu.c

249

server = create_server(_metadata, self, variant, -1);

tools/testing/selftests/net/so_incoming_cpu.c

250

close(server);

tools/testing/selftests/net/so_incoming_cpu.c

258

int server, client;

tools/testing/selftests/net/so_incoming_cpu.c

263

server = create_server(_metadata, self, variant, -1);

tools/testing/selftests/net/so_incoming_cpu.c

268

client = accept(server, &self->addr, &self->addrlen);

tools/testing/selftests/net/tcp_ao/key-management.c

580

static int key_collection_socket(bool server, unsigned int port)

tools/testing/selftests/net/tcp_ao/key-management.c

585

if (server)

tools/testing/selftests/net/tcp_ao/key-management.c

602

if (server) {

tools/testing/selftests/net/tcp_ao/key-management.c

622

server ? "server" : "client", i, collection.nr_keys,

tools/testing/selftests/net/tcp_ao/key-management.c

631

static void verify_counters(const char *tst_name, bool is_listen_sk, bool server,

tools/testing/selftests/net/tcp_ao/key-management.c

645

if (server) {

tools/testing/selftests/net/tcp_ao/key-management.c

680

bool is_listen_sk, bool server)

tools/testing/selftests/net/tcp_ao/key-management.c

707

if (server) {

tools/testing/selftests/net/tcp_ao/seq-ext.c

21

bool server)

tools/testing/selftests/net/tcp_ao/seq-ext.c

26

if (server) {

tools/testing/vsock/control.c

37

bool server)

tools/testing/vsock/control.c

59

if (!server) {

tools/testing/vsock/control.h

8

bool server);