Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* linux/net/sunrpc/clnt.c

2

* linux/net/sunrpc/clnt.c

3

*

3

*

4

* This file contains the high-level RPC interface.

4

* This file contains the high-level RPC interface.

5

* It is modeled as a finite state machine to support both synchronous

5

* It is modeled as a finite state machine to support both synchronous

6

* and asynchronous requests.

6

* and asynchronous requests.

7

*

7

*

8

* - RPC header generation and argument serialization.

8

* - RPC header generation and argument serialization.

9

* - Credential refresh.

9

* - Credential refresh.

10

* - TCP connect handling.

10

* - TCP connect handling.

11

* - Retry of operation when it is suspected the operation failed because

11

* - Retry of operation when it is suspected the operation failed because

12

* of uid squashing on the server, or when the credentials were stale

12

* of uid squashing on the server, or when the credentials were stale

13

* and need to be refreshed, or when a packet was damaged in transit.

13

* and need to be refreshed, or when a packet was damaged in transit.

14

* This may be have to be moved to the VFS layer.

14

* This may be have to be moved to the VFS layer.

15

*

15

*

16

17

18

*/

18

*/

19

20

21

#include <linux/module.h>

21

#include <linux/module.h>

22

#include <linux/types.h>

22

#include <linux/types.h>

23

#include <linux/kallsyms.h>

23

#include <linux/kallsyms.h>

24

#include <linux/mm.h>

24

#include <linux/mm.h>

25

#include <linux/namei.h>

25

#include <linux/namei.h>

26

#include <linux/mount.h>

26

#include <linux/mount.h>

27

#include <linux/slab.h>

27

#include <linux/slab.h>

28

#include <linux/rcupdate.h>

28

#include <linux/rcupdate.h>

29

#include <linux/utsname.h>

29

#include <linux/utsname.h>

30

#include <linux/workqueue.h>

30

#include <linux/workqueue.h>

31

#include <linux/in.h>

31

#include <linux/in.h>

32

#include <linux/in6.h>

32

#include <linux/in6.h>

33

#include <linux/un.h>

33

#include <linux/un.h>

34

35

#include <linux/sunrpc/clnt.h>

35

#include <linux/sunrpc/clnt.h>

36

#include <linux/sunrpc/addr.h>

36

#include <linux/sunrpc/addr.h>

37

#include <linux/sunrpc/rpc_pipe_fs.h>

37

#include <linux/sunrpc/rpc_pipe_fs.h>

38

#include <linux/sunrpc/metrics.h>

38

#include <linux/sunrpc/metrics.h>

39

#include <linux/sunrpc/bc_xprt.h>

39

#include <linux/sunrpc/bc_xprt.h>

40

#include <trace/events/sunrpc.h>

40

#include <trace/events/sunrpc.h>

41

42

#include "sunrpc.h"

42

#include "sunrpc.h"

43

#include "netns.h"

43

#include "netns.h"

44

45

#ifdef RPC_DEBUG

45

#ifdef RPC_DEBUG

46

# define RPCDBG_FACILITY RPCDBG_CALL

46

# define RPCDBG_FACILITY RPCDBG_CALL

47

#endif

47

#endif

48

49

#define dprint_status(t) \

49

#define dprint_status(t) \

50

dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \

50

dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \

51

__func__, t->tk_status)

51

__func__, t->tk_status)

52

53

/*

53

/*

54

* All RPC clients are linked into this list

54

* All RPC clients are linked into this list

55

*/

55

*/

56

57

static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);

57

static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);

58

59

60

static void call_start(struct rpc_task *task);

60

static void call_start(struct rpc_task *task);

61

static void call_reserve(struct rpc_task *task);

61

static void call_reserve(struct rpc_task *task);

62

static void call_reserveresult(struct rpc_task *task);

62

static void call_reserveresult(struct rpc_task *task);

63

static void call_allocate(struct rpc_task *task);

63

static void call_allocate(struct rpc_task *task);

64

static void call_decode(struct rpc_task *task);

64

static void call_decode(struct rpc_task *task);

65

static void call_bind(struct rpc_task *task);

65

static void call_bind(struct rpc_task *task);

66

static void call_bind_status(struct rpc_task *task);

66

static void call_bind_status(struct rpc_task *task);

67

static void call_transmit(struct rpc_task *task);

67

static void call_transmit(struct rpc_task *task);

68

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

68

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

69

static void call_bc_transmit(struct rpc_task *task);

69

static void call_bc_transmit(struct rpc_task *task);

70

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

70

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

71

static void call_status(struct rpc_task *task);

71

static void call_status(struct rpc_task *task);

72

static void call_transmit_status(struct rpc_task *task);

72

static void call_transmit_status(struct rpc_task *task);

73

static void call_refresh(struct rpc_task *task);

73

static void call_refresh(struct rpc_task *task);

74

static void call_refreshresult(struct rpc_task *task);

74

static void call_refreshresult(struct rpc_task *task);

75

static void call_timeout(struct rpc_task *task);

75

static void call_timeout(struct rpc_task *task);

76

static void call_connect(struct rpc_task *task);

76

static void call_connect(struct rpc_task *task);

77

static void call_connect_status(struct rpc_task *task);

77

static void call_connect_status(struct rpc_task *task);

78

79

static __be32 *rpc_encode_header(struct rpc_task *task);

79

static __be32 *rpc_encode_header(struct rpc_task *task);

80

static __be32 *rpc_verify_header(struct rpc_task *task);

80

static __be32 *rpc_verify_header(struct rpc_task *task);

81

static int rpc_ping(struct rpc_clnt *clnt);

81

static int rpc_ping(struct rpc_clnt *clnt);

82

83

static void rpc_register_client(struct rpc_clnt *clnt)

83

static void rpc_register_client(struct rpc_clnt *clnt)

84

{

84

{

85

struct net *net = rpc_net_ns(clnt);

85

struct net *net = rpc_net_ns(clnt);

86

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

86

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

87

88

spin_lock(&sn->rpc_client_lock);

88

spin_lock(&sn->rpc_client_lock);

89

list_add(&clnt->cl_clients, &sn->all_clients);

89

list_add(&clnt->cl_clients, &sn->all_clients);

90

spin_unlock(&sn->rpc_client_lock);

90

spin_unlock(&sn->rpc_client_lock);

91

}

91

}

92

93

static void rpc_unregister_client(struct rpc_clnt *clnt)

93

static void rpc_unregister_client(struct rpc_clnt *clnt)

94

{

94

{

95

struct net *net = rpc_net_ns(clnt);

95

struct net *net = rpc_net_ns(clnt);

96

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

96

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

97

98

spin_lock(&sn->rpc_client_lock);

98

spin_lock(&sn->rpc_client_lock);

99

list_del(&clnt->cl_clients);

99

list_del(&clnt->cl_clients);

100

spin_unlock(&sn->rpc_client_lock);

100

spin_unlock(&sn->rpc_client_lock);

101

}

101

}

102

103

static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)

103

static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)

104

{

104

{

105

rpc_remove_client_dir(clnt);

105

rpc_remove_client_dir(clnt);

106

}

106

}

107

108

static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)

108

static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)

109

{

109

{

110

struct net *net = rpc_net_ns(clnt);

110

struct net *net = rpc_net_ns(clnt);

111

struct super_block *pipefs_sb;

111

struct super_block *pipefs_sb;

112

113

pipefs_sb = rpc_get_sb_net(net);

113

pipefs_sb = rpc_get_sb_net(net);

114

if (pipefs_sb) {

114

if (pipefs_sb) {

115

__rpc_clnt_remove_pipedir(clnt);

115

__rpc_clnt_remove_pipedir(clnt);

116

rpc_put_sb_net(net);

116

rpc_put_sb_net(net);

117

}

117

}

118

}

118

}

119

120

static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,

120

static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,

121

struct rpc_clnt *clnt)

121

struct rpc_clnt *clnt)

122

{

122

{

123

static uint32_t clntid;

123

static uint32_t clntid;

124

const char *dir_name = clnt->cl_program->pipe_dir_name;

124

const char *dir_name = clnt->cl_program->pipe_dir_name;

125

char name[15];

125

char name[15];

126

struct dentry *dir, *dentry;

126

struct dentry *dir, *dentry;

127

128

dir = rpc_d_lookup_sb(sb, dir_name);

128

dir = rpc_d_lookup_sb(sb, dir_name);

129

if (dir == NULL) {

129

if (dir == NULL) {

130

pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);

130

pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);

131

return dir;

131

return dir;

132

}

132

}

133

for (;;) {

133

for (;;) {

134

snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);

134

snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);

135

name[sizeof(name) - 1] = '\0';

135

name[sizeof(name) - 1] = '\0';

136

dentry = rpc_create_client_dir(dir, name, clnt);

136

dentry = rpc_create_client_dir(dir, name, clnt);

137

if (!IS_ERR(dentry))

137

if (!IS_ERR(dentry))

138

break;

138

break;

139

if (dentry == ERR_PTR(-EEXIST))

139

if (dentry == ERR_PTR(-EEXIST))

140

continue;

140

continue;

141

printk(KERN_INFO "RPC: Couldn't create pipefs entry"

141

printk(KERN_INFO "RPC: Couldn't create pipefs entry"

142

" %s/%s, error %ld\n",

142

" %s/%s, error %ld\n",

143

dir_name, name, PTR_ERR(dentry));

143

dir_name, name, PTR_ERR(dentry));

144

break;

144

break;

145

}

145

}

146

dput(dir);

146

dput(dir);

147

return dentry;

147

return dentry;

148

}

148

}

149

150

static int

150

static int

151

rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)

151

rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)

152

{

152

{

153

struct dentry *dentry;

153

struct dentry *dentry;

154

155

if (clnt->cl_program->pipe_dir_name != NULL) {

155

if (clnt->cl_program->pipe_dir_name != NULL) {

156

dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);

156

dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);

157

if (IS_ERR(dentry))

157

if (IS_ERR(dentry))

158

return PTR_ERR(dentry);

158

return PTR_ERR(dentry);

159

}

159

}

160

return 0;

160

return 0;

161

}

161

}

162

163

static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)

163

static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)

164

{

164

{

165

if (clnt->cl_program->pipe_dir_name == NULL)

165

if (clnt->cl_program->pipe_dir_name == NULL)

166

return 1;

166

return 1;

167

168

switch (event) {

168

switch (event) {

169

case RPC_PIPEFS_MOUNT:

169

case RPC_PIPEFS_MOUNT:

170

if (clnt->cl_pipedir_objects.pdh_dentry != NULL)

170

if (clnt->cl_pipedir_objects.pdh_dentry != NULL)

171

return 1;

171

return 1;

172

if (atomic_read(&clnt->cl_count) == 0)

172

if (atomic_read(&clnt->cl_count) == 0)

173

return 1;

173

return 1;

174

break;

174

break;

175

case RPC_PIPEFS_UMOUNT:

175

case RPC_PIPEFS_UMOUNT:

176

if (clnt->cl_pipedir_objects.pdh_dentry == NULL)

176

if (clnt->cl_pipedir_objects.pdh_dentry == NULL)

177

return 1;

177

return 1;

178

break;

178

break;

179

}

179

}

180

return 0;

180

return 0;

181

}

181

}

182

183

static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,

183

static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,

184

struct super_block *sb)

184

struct super_block *sb)

185

{

185

{

186

struct dentry *dentry;

186

struct dentry *dentry;

187

int err = 0;

187

int err = 0;

188

189

switch (event) {

189

switch (event) {

190

case RPC_PIPEFS_MOUNT:

190

case RPC_PIPEFS_MOUNT:

191

dentry = rpc_setup_pipedir_sb(sb, clnt);

191

dentry = rpc_setup_pipedir_sb(sb, clnt);

192

if (!dentry)

192

if (!dentry)

193

return -ENOENT;

193

return -ENOENT;

194

if (IS_ERR(dentry))

194

if (IS_ERR(dentry))

195

return PTR_ERR(dentry);

195

return PTR_ERR(dentry);

196

break;

196

break;

197

case RPC_PIPEFS_UMOUNT:

197

case RPC_PIPEFS_UMOUNT:

198

__rpc_clnt_remove_pipedir(clnt);

198

__rpc_clnt_remove_pipedir(clnt);

199

break;

199

break;

200

default:

200

default:

201

printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);

201

printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);

202

return -ENOTSUPP;

202

return -ENOTSUPP;

203

}

203

}

204

return err;

204

return err;

205

}

205

}

206

207

static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,

207

static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,

208

struct super_block *sb)

208

struct super_block *sb)

209

{

209

{

210

int error = 0;

210

int error = 0;

211

212

for (;; clnt = clnt->cl_parent) {

212

for (;; clnt = clnt->cl_parent) {

213

if (!rpc_clnt_skip_event(clnt, event))

213

if (!rpc_clnt_skip_event(clnt, event))

214

error = __rpc_clnt_handle_event(clnt, event, sb);

214

error = __rpc_clnt_handle_event(clnt, event, sb);

215

if (error || clnt == clnt->cl_parent)

215

if (error || clnt == clnt->cl_parent)

216

break;

216

break;

217

}

217

}

218

return error;

218

return error;

219

}

219

}

220

221

static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)

221

static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)

222

{

222

{

223

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

223

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

224

struct rpc_clnt *clnt;

224

struct rpc_clnt *clnt;

225

226

spin_lock(&sn->rpc_client_lock);

226

spin_lock(&sn->rpc_client_lock);

227

list_for_each_entry(clnt, &sn->all_clients, cl_clients) {

227

list_for_each_entry(clnt, &sn->all_clients, cl_clients) {

228

if (rpc_clnt_skip_event(clnt, event))

228

if (rpc_clnt_skip_event(clnt, event))

229

continue;

229

continue;

230

spin_unlock(&sn->rpc_client_lock);

230

spin_unlock(&sn->rpc_client_lock);

231

return clnt;

231

return clnt;

232

}

232

}

233

spin_unlock(&sn->rpc_client_lock);

233

spin_unlock(&sn->rpc_client_lock);

234

return NULL;

234

return NULL;

235

}

235

}

236

237

static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,

237

static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,

238

void *ptr)

238

void *ptr)

239

{

239

{

240

struct super_block *sb = ptr;

240

struct super_block *sb = ptr;

241

struct rpc_clnt *clnt;

241

struct rpc_clnt *clnt;

242

int error = 0;

242

int error = 0;

243

244

while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {

244

while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {

245

error = __rpc_pipefs_event(clnt, event, sb);

245

error = __rpc_pipefs_event(clnt, event, sb);

246

if (error)

246

if (error)

247

break;

247

break;

248

}

248

}

249

return error;

249

return error;

250

}

250

}

251

252

static struct notifier_block rpc_clients_block = {

252

static struct notifier_block rpc_clients_block = {

253

.notifier_call = rpc_pipefs_event,

253

.notifier_call = rpc_pipefs_event,

254

.priority = SUNRPC_PIPEFS_RPC_PRIO,

254

.priority = SUNRPC_PIPEFS_RPC_PRIO,

255

};

255

};

256

257

int rpc_clients_notifier_register(void)

257

int rpc_clients_notifier_register(void)

258

{

258

{

259

return rpc_pipefs_notifier_register(&rpc_clients_block);

259

return rpc_pipefs_notifier_register(&rpc_clients_block);

260

}

260

}

261

262

void rpc_clients_notifier_unregister(void)

262

void rpc_clients_notifier_unregister(void)

263

{

263

{

264

return rpc_pipefs_notifier_unregister(&rpc_clients_block);

264

return rpc_pipefs_notifier_unregister(&rpc_clients_block);

265

}

265

}

266

267

static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,

267

static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,

268

struct rpc_xprt *xprt,

268

struct rpc_xprt *xprt,

269

const struct rpc_timeout *timeout)

269

const struct rpc_timeout *timeout)

270

{

270

{

271

struct rpc_xprt *old;

271

struct rpc_xprt *old;

272

273

spin_lock(&clnt->cl_lock);

273

spin_lock(&clnt->cl_lock);

274

old = rcu_dereference_protected(clnt->cl_xprt,

274

old = rcu_dereference_protected(clnt->cl_xprt,

275

lockdep_is_held(&clnt->cl_lock));

275

lockdep_is_held(&clnt->cl_lock));

276

277

if (!xprt_bound(xprt))

277

if (!xprt_bound(xprt))

278

clnt->cl_autobind = 1;

278

clnt->cl_autobind = 1;

279

280

clnt->cl_timeout = timeout;

280

clnt->cl_timeout = timeout;

281

rcu_assign_pointer(clnt->cl_xprt, xprt);

281

rcu_assign_pointer(clnt->cl_xprt, xprt);

282

spin_unlock(&clnt->cl_lock);

282

spin_unlock(&clnt->cl_lock);

283

284

return old;

284

return old;

285

}

285

}

286

287

static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)

287

static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)

288

{

288

{

289

clnt->cl_nodelen = strlen(nodename);

289

clnt->cl_nodelen = strlen(nodename);

290

if (clnt->cl_nodelen > UNX_MAXNODENAME)

290

if (clnt->cl_nodelen > UNX_MAXNODENAME)

291

clnt->cl_nodelen = UNX_MAXNODENAME;

291

clnt->cl_nodelen = UNX_MAXNODENAME;

292

memcpy(clnt->cl_nodename, nodename, clnt->cl_nodelen);

292

memcpy(clnt->cl_nodename, nodename, clnt->cl_nodelen);

293

}

293

}

294

295

static int rpc_client_register(struct rpc_clnt *clnt,

295

static int rpc_client_register(struct rpc_clnt *clnt,

296

rpc_authflavor_t pseudoflavor,

296

rpc_authflavor_t pseudoflavor,

297

const char *client_name)

297

const char *client_name)

298

{

298

{

299

struct rpc_auth_create_args auth_args = {

299

struct rpc_auth_create_args auth_args = {

300

.pseudoflavor = pseudoflavor,

300

.pseudoflavor = pseudoflavor,

301

.target_name = client_name,

301

.target_name = client_name,

302

};

302

};

303

struct rpc_auth *auth;

303

struct rpc_auth *auth;

304

struct net *net = rpc_net_ns(clnt);

304

struct net *net = rpc_net_ns(clnt);

305

struct super_block *pipefs_sb;

305

struct super_block *pipefs_sb;

306

int err;

306

int err;

307

308

pipefs_sb = rpc_get_sb_net(net);

308

pipefs_sb = rpc_get_sb_net(net);

309

if (pipefs_sb) {

309

if (pipefs_sb) {

310

err = rpc_setup_pipedir(pipefs_sb, clnt);

310

err = rpc_setup_pipedir(pipefs_sb, clnt);

311

if (err)

311

if (err)

312

goto out;

312

goto out;

313

}

313

}

314

315

rpc_register_client(clnt);

315

rpc_register_client(clnt);

316

if (pipefs_sb)

316

if (pipefs_sb)

317

rpc_put_sb_net(net);

317

rpc_put_sb_net(net);

318

319

auth = rpcauth_create(&auth_args, clnt);

319

auth = rpcauth_create(&auth_args, clnt);

320

if (IS_ERR(auth)) {

320

if (IS_ERR(auth)) {

321

dprintk("RPC: Couldn't create auth handle (flavor %u)\n",

321

dprintk("RPC: Couldn't create auth handle (flavor %u)\n",

322

pseudoflavor);

322

pseudoflavor);

323

err = PTR_ERR(auth);

323

err = PTR_ERR(auth);

324

goto err_auth;

324

goto err_auth;

325

}

325

}

326

return 0;

326

return 0;

327

err_auth:

327

err_auth:

328

pipefs_sb = rpc_get_sb_net(net);

328

pipefs_sb = rpc_get_sb_net(net);

329

rpc_unregister_client(clnt);

329

rpc_unregister_client(clnt);

330

__rpc_clnt_remove_pipedir(clnt);

330

__rpc_clnt_remove_pipedir(clnt);

331

out:

331

out:

332

if (pipefs_sb)

332

if (pipefs_sb)

333

rpc_put_sb_net(net);

333

rpc_put_sb_net(net);

334

return err;

334

return err;

335

}

335

}

336

337

static DEFINE_IDA(rpc_clids);

337

static DEFINE_IDA(rpc_clids);

338

339

static int rpc_alloc_clid(struct rpc_clnt *clnt)

339

static int rpc_alloc_clid(struct rpc_clnt *clnt)

340

{

340

{

341

int clid;

341

int clid;

342

343

clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);

343

clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);

344

if (clid < 0)

344

if (clid < 0)

345

return clid;

345

return clid;

346

clnt->cl_clid = clid;

346

clnt->cl_clid = clid;

347

return 0;

347

return 0;

348

}

348

}

349

350

static void rpc_free_clid(struct rpc_clnt *clnt)

350

static void rpc_free_clid(struct rpc_clnt *clnt)

351

{

351

{

352

ida_simple_remove(&rpc_clids, clnt->cl_clid);

352

ida_simple_remove(&rpc_clids, clnt->cl_clid);

353

}

353

}

354

355

static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,

355

static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,

356

struct rpc_xprt *xprt,

356

struct rpc_xprt *xprt,

357

struct rpc_clnt *parent)

357

struct rpc_clnt *parent)

358

{

358

{

359

const struct rpc_program *program = args->program;

359

const struct rpc_program *program = args->program;

360

const struct rpc_version *version;

360

const struct rpc_version *version;

361

struct rpc_clnt *clnt = NULL;

361

struct rpc_clnt *clnt = NULL;

362

const struct rpc_timeout *timeout;

362

const struct rpc_timeout *timeout;

363

int err;

363

int err;

364

365

/* sanity check the name before trying to print it */

365

/* sanity check the name before trying to print it */

366

dprintk("RPC: creating %s client for %s (xprt %p)\n",

366

dprintk("RPC: creating %s client for %s (xprt %p)\n",

367

program->name, args->servername, xprt);

367

program->name, args->servername, xprt);

368

369

err = rpciod_up();

369

err = rpciod_up();

370

if (err)

370

if (err)

371

goto out_no_rpciod;

371

goto out_no_rpciod;

372

373

err = -EINVAL;

373

err = -EINVAL;

374

if (args->version >= program->nrvers)

374

if (args->version >= program->nrvers)

375

goto out_err;

375

goto out_err;

376

version = program->version[args->version];

376

version = program->version[args->version];

377

if (version == NULL)

377

if (version == NULL)

378

goto out_err;

378

goto out_err;

379

380

err = -ENOMEM;

380

err = -ENOMEM;

381

clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);

381

clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);

382

if (!clnt)

382

if (!clnt)

383

goto out_err;

383

goto out_err;

384

clnt->cl_parent = parent ? : clnt;

384

clnt->cl_parent = parent ? : clnt;

385

386

err = rpc_alloc_clid(clnt);

386

err = rpc_alloc_clid(clnt);

387

if (err)

387

if (err)

388

goto out_no_clid;

388

goto out_no_clid;

389

390

clnt->cl_procinfo = version->procs;

390

clnt->cl_procinfo = version->procs;

391

clnt->cl_maxproc = version->nrprocs;

391

clnt->cl_maxproc = version->nrprocs;

392

clnt->cl_prog = args->prognumber ? : program->number;

392

clnt->cl_prog = args->prognumber ? : program->number;

393

clnt->cl_vers = version->number;

393

clnt->cl_vers = version->number;

394

clnt->cl_stats = program->stats;

394

clnt->cl_stats = program->stats;

395

clnt->cl_metrics = rpc_alloc_iostats(clnt);

395

clnt->cl_metrics = rpc_alloc_iostats(clnt);

396

rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);

396

rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);

397

err = -ENOMEM;

397

err = -ENOMEM;

398

if (clnt->cl_metrics == NULL)

398

if (clnt->cl_metrics == NULL)

399

goto out_no_stats;

399

goto out_no_stats;

400

clnt->cl_program = program;

400

clnt->cl_program = program;

401

INIT_LIST_HEAD(&clnt->cl_tasks);

401

INIT_LIST_HEAD(&clnt->cl_tasks);

402

spin_lock_init(&clnt->cl_lock);

402

spin_lock_init(&clnt->cl_lock);

403

404

timeout = xprt->timeout;

404

timeout = xprt->timeout;

405

if (args->timeout != NULL) {

405

if (args->timeout != NULL) {

406

memcpy(&clnt->cl_timeout_default, args->timeout,

406

memcpy(&clnt->cl_timeout_default, args->timeout,

407

sizeof(clnt->cl_timeout_default));

407

sizeof(clnt->cl_timeout_default));

408

timeout = &clnt->cl_timeout_default;

408

timeout = &clnt->cl_timeout_default;

409

}

409

}

410

411

rpc_clnt_set_transport(clnt, xprt, timeout);

411

rpc_clnt_set_transport(clnt, xprt, timeout);

412

413

clnt->cl_rtt = &clnt->cl_rtt_default;

413

clnt->cl_rtt = &clnt->cl_rtt_default;

414

rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);

414

rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);

415

416

atomic_set(&clnt->cl_count, 1);

416

atomic_set(&clnt->cl_count, 1);

417

418

/* save the nodename */

418

/* save the nodename */

419

rpc_clnt_set_nodename(clnt, utsname()->nodename);

419

rpc_clnt_set_nodename(clnt, utsname()->nodename);

420

421

err = rpc_client_register(clnt, args->authflavor, args->client_name);

421

err = rpc_client_register(clnt, args->authflavor, args->client_name);

422

if (err)

422

if (err)

423

goto out_no_path;

423

goto out_no_path;

424

if (parent)

424

if (parent)

425

atomic_inc(&parent->cl_count);

425

atomic_inc(&parent->cl_count);

426

return clnt;

426

return clnt;

427

428

out_no_path:

428

out_no_path:

429

rpc_free_iostats(clnt->cl_metrics);

429

rpc_free_iostats(clnt->cl_metrics);

430

out_no_stats:

430

out_no_stats:

431

rpc_free_clid(clnt);

431

rpc_free_clid(clnt);

432

out_no_clid:

432

out_no_clid:

433

kfree(clnt);

433

kfree(clnt);

434

out_err:

434

out_err:

435

rpciod_down();

435

rpciod_down();

436

out_no_rpciod:

436

out_no_rpciod:

437

xprt_put(xprt);

437

xprt_put(xprt);

438

return ERR_PTR(err);

438

return ERR_PTR(err);

439

}

439

}

440

441

/**

441

/**

442

* rpc_create - create an RPC client and transport with one call

442

* rpc_create - create an RPC client and transport with one call

443

* @args: rpc_clnt create argument structure

443

* @args: rpc_clnt create argument structure

444

*

444

*

445

* Creates and initializes an RPC transport and an RPC client.

445

* Creates and initializes an RPC transport and an RPC client.

446

*

446

*

447

* It can ping the server in order to determine if it is up, and to see if

447

* It can ping the server in order to determine if it is up, and to see if

448

* it supports this program and version. RPC_CLNT_CREATE_NOPING disables

448

* it supports this program and version. RPC_CLNT_CREATE_NOPING disables

449

* this behavior so asynchronous tasks can also use rpc_create.

449

* this behavior so asynchronous tasks can also use rpc_create.

450

*/

450

*/

451

struct rpc_clnt *rpc_create(struct rpc_create_args *args)

451

struct rpc_clnt *rpc_create(struct rpc_create_args *args)

452

{

452

{

453

struct rpc_xprt *xprt;

453

struct rpc_xprt *xprt;

454

struct rpc_clnt *clnt;

454

struct rpc_clnt *clnt;

455

struct xprt_create xprtargs = {

455

struct xprt_create xprtargs = {

456

.net = args->net,

456

.net = args->net,

457

.ident = args->protocol,

457

.ident = args->protocol,

458

.srcaddr = args->saddress,

458

.srcaddr = args->saddress,

459

.dstaddr = args->address,

459

.dstaddr = args->address,

460

.addrlen = args->addrsize,

460

.addrlen = args->addrsize,

461

.servername = args->servername,

461

.servername = args->servername,

462

.bc_xprt = args->bc_xprt,

462

.bc_xprt = args->bc_xprt,

463

};

463

};

464

char servername[48];

464

char servername[48];

465

466

if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)

466

if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)

467

xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;

467

xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;

468

if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)

468

if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)

469

xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;

469

xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;

470

/*

470

/*

471

* If the caller chooses not to specify a hostname, whip

471

* If the caller chooses not to specify a hostname, whip

472

* up a string representation of the passed-in address.

472

* up a string representation of the passed-in address.

473

*/

473

*/

474

if (xprtargs.servername == NULL) {

474

if (xprtargs.servername == NULL) {

475

struct sockaddr_un *sun =

475

struct sockaddr_un *sun =

476

(struct sockaddr_un *)args->address;

476

(struct sockaddr_un *)args->address;

477

struct sockaddr_in *sin =

477

struct sockaddr_in *sin =

478

(struct sockaddr_in *)args->address;

478

(struct sockaddr_in *)args->address;

479

struct sockaddr_in6 *sin6 =

479

struct sockaddr_in6 *sin6 =

480

(struct sockaddr_in6 *)args->address;

480

(struct sockaddr_in6 *)args->address;

481

482

servername[0] = '\0';

482

servername[0] = '\0';

483

switch (args->address->sa_family) {

483

switch (args->address->sa_family) {

484

case AF_LOCAL:

484

case AF_LOCAL:

485

snprintf(servername, sizeof(servername), "%s",

485

snprintf(servername, sizeof(servername), "%s",

486

sun->sun_path);

486

sun->sun_path);

487

break;

487

break;

488

case AF_INET:

488

case AF_INET:

489

snprintf(servername, sizeof(servername), "%pI4",

489

snprintf(servername, sizeof(servername), "%pI4",

490

&sin->sin_addr.s_addr);

490

&sin->sin_addr.s_addr);

491

break;

491

break;

492

case AF_INET6:

492

case AF_INET6:

493

snprintf(servername, sizeof(servername), "%pI6",

493

snprintf(servername, sizeof(servername), "%pI6",

494

&sin6->sin6_addr);

494

&sin6->sin6_addr);

495

break;

495

break;

496

default:

496

default:

497

/* caller wants default server name, but

497

/* caller wants default server name, but

498

* address family isn't recognized. */

498

* address family isn't recognized. */

499

return ERR_PTR(-EINVAL);

499

return ERR_PTR(-EINVAL);

500

}

500

}

501

xprtargs.servername = servername;

501

xprtargs.servername = servername;

502

}

502

}

503

504

xprt = xprt_create_transport(&xprtargs);

504

xprt = xprt_create_transport(&xprtargs);

505

if (IS_ERR(xprt))

505

if (IS_ERR(xprt))

506

return (struct rpc_clnt *)xprt;

506

return (struct rpc_clnt *)xprt;

507

508

/*

508

/*

509

* By default, kernel RPC client connects from a reserved port.

509

* By default, kernel RPC client connects from a reserved port.

510

* CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,

510

* CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,

511

* but it is always enabled for rpciod, which handles the connect

511

* but it is always enabled for rpciod, which handles the connect

512

* operation.

512

* operation.

513

*/

513

*/

514

xprt->resvport = 1;

514

xprt->resvport = 1;

515

if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)

515

if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)

516

xprt->resvport = 0;

516

xprt->resvport = 0;

517

518

clnt = rpc_new_client(args, xprt, NULL);

518

clnt = rpc_new_client(args, xprt, NULL);

519

if (IS_ERR(clnt))

519

if (IS_ERR(clnt))

520

return clnt;

520

return clnt;

521

522

if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {

522

if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {

523

int err = rpc_ping(clnt);

523

int err = rpc_ping(clnt);

524

if (err != 0) {

524

if (err != 0) {

525

rpc_shutdown_client(clnt);

525

rpc_shutdown_client(clnt);

526

return ERR_PTR(err);

526

return ERR_PTR(err);

527

}

527

}

528

}

528

}

529

530

clnt->cl_softrtry = 1;

530

clnt->cl_softrtry = 1;

531

if (args->flags & RPC_CLNT_CREATE_HARDRTRY)

531

if (args->flags & RPC_CLNT_CREATE_HARDRTRY)

532

clnt->cl_softrtry = 0;

532

clnt->cl_softrtry = 0;

533

534

if (args->flags & RPC_CLNT_CREATE_AUTOBIND)

534

if (args->flags & RPC_CLNT_CREATE_AUTOBIND)

535

clnt->cl_autobind = 1;

535

clnt->cl_autobind = 1;

536

if (args->flags & RPC_CLNT_CREATE_DISCRTRY)

536

if (args->flags & RPC_CLNT_CREATE_DISCRTRY)

537

clnt->cl_discrtry = 1;

537

clnt->cl_discrtry = 1;

538

if (!(args->flags & RPC_CLNT_CREATE_QUIET))

538

if (!(args->flags & RPC_CLNT_CREATE_QUIET))

539

clnt->cl_chatty = 1;

539

clnt->cl_chatty = 1;

540

541

return clnt;

541

return clnt;

542

}

542

}

543

EXPORT_SYMBOL_GPL(rpc_create);

543

EXPORT_SYMBOL_GPL(rpc_create);

544

545

/*

545

/*

546

* This function clones the RPC client structure. It allows us to share the

546

* This function clones the RPC client structure. It allows us to share the

547

* same transport while varying parameters such as the authentication

547

* same transport while varying parameters such as the authentication

548

* flavour.

548

* flavour.

549

*/

549

*/

550

static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,

550

static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,

551

struct rpc_clnt *clnt)

551

struct rpc_clnt *clnt)

552

{

552

{

553

struct rpc_xprt *xprt;

553

struct rpc_xprt *xprt;

554

struct rpc_clnt *new;

554

struct rpc_clnt *new;

555

int err;

555

int err;

556

557

err = -ENOMEM;

557

err = -ENOMEM;

558

rcu_read_lock();

558

rcu_read_lock();

559

xprt = xprt_get(rcu_dereference(clnt->cl_xprt));

559

xprt = xprt_get(rcu_dereference(clnt->cl_xprt));

560

rcu_read_unlock();

560

rcu_read_unlock();

561

if (xprt == NULL)

561

if (xprt == NULL)

562

goto out_err;

562

goto out_err;

563

args->servername = xprt->servername;

563

args->servername = xprt->servername;

564

565

new = rpc_new_client(args, xprt, clnt);

565

new = rpc_new_client(args, xprt, clnt);

566

if (IS_ERR(new)) {

566

if (IS_ERR(new)) {

567

err = PTR_ERR(new);

567

err = PTR_ERR(new);

568

goto out_err;

568

goto out_err;

569

}

569

}

570

571

/* Turn off autobind on clones */

571

/* Turn off autobind on clones */

572

new->cl_autobind = 0;

572

new->cl_autobind = 0;

573

new->cl_softrtry = clnt->cl_softrtry;

573

new->cl_softrtry = clnt->cl_softrtry;

574

new->cl_discrtry = clnt->cl_discrtry;

574

new->cl_discrtry = clnt->cl_discrtry;

575

new->cl_chatty = clnt->cl_chatty;

575

new->cl_chatty = clnt->cl_chatty;

576

return new;

576

return new;

577

578

out_err:

578

out_err:

579

dprintk("RPC: %s: returned error %d\n", __func__, err);

579

dprintk("RPC: %s: returned error %d\n", __func__, err);

580

return ERR_PTR(err);

580

return ERR_PTR(err);

581

}

581

}

582

583

/**

583

/**

584

* rpc_clone_client - Clone an RPC client structure

584

* rpc_clone_client - Clone an RPC client structure

585

*

585

*

586

* @clnt: RPC client whose parameters are copied

586

* @clnt: RPC client whose parameters are copied

587

*

587

*

588

* Returns a fresh RPC client or an ERR_PTR.

588

* Returns a fresh RPC client or an ERR_PTR.

589

*/

589

*/

590

struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)

590

struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)

591

{

591

{

592

struct rpc_create_args args = {

592

struct rpc_create_args args = {

593

.program = clnt->cl_program,

593

.program = clnt->cl_program,

594

.prognumber = clnt->cl_prog,

594

.prognumber = clnt->cl_prog,

595

.version = clnt->cl_vers,

595

.version = clnt->cl_vers,

596

.authflavor = clnt->cl_auth->au_flavor,

596

.authflavor = clnt->cl_auth->au_flavor,

597

};

597

};

598

return __rpc_clone_client(&args, clnt);

598

return __rpc_clone_client(&args, clnt);

599

}

599

}

600

EXPORT_SYMBOL_GPL(rpc_clone_client);

600

EXPORT_SYMBOL_GPL(rpc_clone_client);

601

602

/**

602

/**

603

* rpc_clone_client_set_auth - Clone an RPC client structure and set its auth

603

* rpc_clone_client_set_auth - Clone an RPC client structure and set its auth

604

*

604

*

605

* @clnt: RPC client whose parameters are copied

605

* @clnt: RPC client whose parameters are copied

606

* @flavor: security flavor for new client

606

* @flavor: security flavor for new client

607

*

607

*

608

* Returns a fresh RPC client or an ERR_PTR.

608

* Returns a fresh RPC client or an ERR_PTR.

609

*/

609

*/

610

struct rpc_clnt *

610

struct rpc_clnt *

611

rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)

611

rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)

612

{

612

{

613

struct rpc_create_args args = {

613

struct rpc_create_args args = {

614

.program = clnt->cl_program,

614

.program = clnt->cl_program,

615

.prognumber = clnt->cl_prog,

615

.prognumber = clnt->cl_prog,

616

.version = clnt->cl_vers,

616

.version = clnt->cl_vers,

617

.authflavor = flavor,

617

.authflavor = flavor,

618

};

618

};

619

return __rpc_clone_client(&args, clnt);

619

return __rpc_clone_client(&args, clnt);

620

}

620

}

621

EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);

621

EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);

622

623

/**

623

/**

624

* rpc_switch_client_transport: switch the RPC transport on the fly

624

* rpc_switch_client_transport: switch the RPC transport on the fly

625

* @clnt: pointer to a struct rpc_clnt

625

* @clnt: pointer to a struct rpc_clnt

626

* @args: pointer to the new transport arguments

626

* @args: pointer to the new transport arguments

627

* @timeout: pointer to the new timeout parameters

627

* @timeout: pointer to the new timeout parameters

628

*

628

*

629

* This function allows the caller to switch the RPC transport for the

629

* This function allows the caller to switch the RPC transport for the

630

* rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS

630

* rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS

631

* server, for instance. It assumes that the caller has ensured that

631

* server, for instance. It assumes that the caller has ensured that

632

* there are no active RPC tasks by using some form of locking.

632

* there are no active RPC tasks by using some form of locking.

633

*

633

*

634

* Returns zero if "clnt" is now using the new xprt. Otherwise a

634

* Returns zero if "clnt" is now using the new xprt. Otherwise a

635

* negative errno is returned, and "clnt" continues to use the old

635

* negative errno is returned, and "clnt" continues to use the old

636

* xprt.

636

* xprt.

637

*/

637

*/

638

int rpc_switch_client_transport(struct rpc_clnt *clnt,

638

int rpc_switch_client_transport(struct rpc_clnt *clnt,

639

struct xprt_create *args,

639

struct xprt_create *args,

640

const struct rpc_timeout *timeout)

640

const struct rpc_timeout *timeout)

641

{

641

{

642

const struct rpc_timeout *old_timeo;

642

const struct rpc_timeout *old_timeo;

643

rpc_authflavor_t pseudoflavor;

643

rpc_authflavor_t pseudoflavor;

644

struct rpc_xprt *xprt, *old;

644

struct rpc_xprt *xprt, *old;

645

struct rpc_clnt *parent;

645

struct rpc_clnt *parent;

646

int err;

646

int err;

647

648

xprt = xprt_create_transport(args);

648

xprt = xprt_create_transport(args);

649

if (IS_ERR(xprt)) {

649

if (IS_ERR(xprt)) {

650

dprintk("RPC: failed to create new xprt for clnt %p\n",

650

dprintk("RPC: failed to create new xprt for clnt %p\n",

651

clnt);

651

clnt);

652

return PTR_ERR(xprt);

652

return PTR_ERR(xprt);

653

}

653

}

654

655

pseudoflavor = clnt->cl_auth->au_flavor;

655

pseudoflavor = clnt->cl_auth->au_flavor;

656

657

old_timeo = clnt->cl_timeout;

657

old_timeo = clnt->cl_timeout;

658

old = rpc_clnt_set_transport(clnt, xprt, timeout);

658

old = rpc_clnt_set_transport(clnt, xprt, timeout);

659

660

rpc_unregister_client(clnt);

660

rpc_unregister_client(clnt);

661

__rpc_clnt_remove_pipedir(clnt);

661

__rpc_clnt_remove_pipedir(clnt);

662

663

/*

663

/*

664

* A new transport was created. "clnt" therefore

664

* A new transport was created. "clnt" therefore

665

* becomes the root of a new cl_parent tree. clnt's

665

* becomes the root of a new cl_parent tree. clnt's

666

* children, if it has any, still point to the old xprt.

666

* children, if it has any, still point to the old xprt.

667

*/

667

*/

668

parent = clnt->cl_parent;

668

parent = clnt->cl_parent;

669

clnt->cl_parent = clnt;

669

clnt->cl_parent = clnt;

670

671

/*

671

/*

672

* The old rpc_auth cache cannot be re-used. GSS

672

* The old rpc_auth cache cannot be re-used. GSS

673

* contexts in particular are between a single

673

* contexts in particular are between a single

674

* client and server.

674

* client and server.

675

*/

675

*/

676

err = rpc_client_register(clnt, pseudoflavor, NULL);

676

err = rpc_client_register(clnt, pseudoflavor, NULL);

677

if (err)

677

if (err)

678

goto out_revert;

678

goto out_revert;

679

680

synchronize_rcu();

680

synchronize_rcu();

681

if (parent != clnt)

681

if (parent != clnt)

682

rpc_release_client(parent);

682

rpc_release_client(parent);

683

xprt_put(old);

683

xprt_put(old);

684

dprintk("RPC: replaced xprt for clnt %p\n", clnt);

684

dprintk("RPC: replaced xprt for clnt %p\n", clnt);

685

return 0;

685

return 0;

686

687

out_revert:

687

out_revert:

688

rpc_clnt_set_transport(clnt, old, old_timeo);

688

rpc_clnt_set_transport(clnt, old, old_timeo);

689

clnt->cl_parent = parent;

689

clnt->cl_parent = parent;

690

rpc_client_register(clnt, pseudoflavor, NULL);

690

rpc_client_register(clnt, pseudoflavor, NULL);

691

xprt_put(xprt);

691

xprt_put(xprt);

692

dprintk("RPC: failed to switch xprt for clnt %p\n", clnt);

692

dprintk("RPC: failed to switch xprt for clnt %p\n", clnt);

693

return err;

693

return err;

694

}

694

}

695

EXPORT_SYMBOL_GPL(rpc_switch_client_transport);

695

EXPORT_SYMBOL_GPL(rpc_switch_client_transport);

696

697

/*

697

/*

698

* Kill all tasks for the given client.

698

* Kill all tasks for the given client.

699

* XXX: kill their descendants as well?

699

* XXX: kill their descendants as well?

700

*/

700

*/

701

void rpc_killall_tasks(struct rpc_clnt *clnt)

701

void rpc_killall_tasks(struct rpc_clnt *clnt)

702

{

702

{

703

struct rpc_task *rovr;

703

struct rpc_task *rovr;

704

705

706

if (list_empty(&clnt->cl_tasks))

706

if (list_empty(&clnt->cl_tasks))

707

return;

707

return;

708

dprintk("RPC: killing all tasks for client %p\n", clnt);

708

dprintk("RPC: killing all tasks for client %p\n", clnt);

709

/*

709

/*

710

* Spin lock all_tasks to prevent changes...

710

* Spin lock all_tasks to prevent changes...

711

*/

711

*/

712

spin_lock(&clnt->cl_lock);

712

spin_lock(&clnt->cl_lock);

713

list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {

713

list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {

714

if (!RPC_IS_ACTIVATED(rovr))

714

if (!RPC_IS_ACTIVATED(rovr))

715

continue;

715

continue;

716

if (!(rovr->tk_flags & RPC_TASK_KILLED)) {

716

if (!(rovr->tk_flags & RPC_TASK_KILLED)) {

717

rovr->tk_flags |= RPC_TASK_KILLED;

717

rovr->tk_flags |= RPC_TASK_KILLED;

718

rpc_exit(rovr, -EIO);

718

rpc_exit(rovr, -EIO);

719

if (RPC_IS_QUEUED(rovr))

719

if (RPC_IS_QUEUED(rovr))

720

rpc_wake_up_queued_task(rovr->tk_waitqueue,

720

rpc_wake_up_queued_task(rovr->tk_waitqueue,

721

rovr);

721

rovr);

722

}

722

}

723

}

723

}

724

spin_unlock(&clnt->cl_lock);

724

spin_unlock(&clnt->cl_lock);

725

}

725

}

726

EXPORT_SYMBOL_GPL(rpc_killall_tasks);

726

EXPORT_SYMBOL_GPL(rpc_killall_tasks);

727

728

/*

728

/*

729

* Properly shut down an RPC client, terminating all outstanding

729

* Properly shut down an RPC client, terminating all outstanding

730

* requests.

730

* requests.

731

*/

731

*/

732

void rpc_shutdown_client(struct rpc_clnt *clnt)

732

void rpc_shutdown_client(struct rpc_clnt *clnt)

733

{

733

{

734

might_sleep();

734

might_sleep();

735

736

dprintk_rcu("RPC: shutting down %s client for %s\n",

736

dprintk_rcu("RPC: shutting down %s client for %s\n",

737

clnt->cl_program->name,

737

clnt->cl_program->name,

738

rcu_dereference(clnt->cl_xprt)->servername);

738

rcu_dereference(clnt->cl_xprt)->servername);

739

740

while (!list_empty(&clnt->cl_tasks)) {

740

while (!list_empty(&clnt->cl_tasks)) {

741

rpc_killall_tasks(clnt);

741

rpc_killall_tasks(clnt);

742

wait_event_timeout(destroy_wait,

742

wait_event_timeout(destroy_wait,

743

list_empty(&clnt->cl_tasks), 1*HZ);

743

list_empty(&clnt->cl_tasks), 1*HZ);

744

}

744

}

745

746

rpc_release_client(clnt);

746

rpc_release_client(clnt);

747

}

747

}

748

EXPORT_SYMBOL_GPL(rpc_shutdown_client);

748

EXPORT_SYMBOL_GPL(rpc_shutdown_client);

749

750

/*

750

/*

751

* Free an RPC client

751

* Free an RPC client

752

*/

752

*/

753

static struct rpc_clnt *

753

static struct rpc_clnt *

754

rpc_free_client(struct rpc_clnt *clnt)

754

rpc_free_client(struct rpc_clnt *clnt)

755

{

755

{

756

struct rpc_clnt *parent = NULL;

756

struct rpc_clnt *parent = NULL;

757

758

dprintk_rcu("RPC: destroying %s client for %s\n",

758

dprintk_rcu("RPC: destroying %s client for %s\n",

759

clnt->cl_program->name,

759

clnt->cl_program->name,

760

rcu_dereference(clnt->cl_xprt)->servername);

760

rcu_dereference(clnt->cl_xprt)->servername);

761

if (clnt->cl_parent != clnt)

761

if (clnt->cl_parent != clnt)

762

parent = clnt->cl_parent;

762

parent = clnt->cl_parent;

763

rpc_clnt_remove_pipedir(clnt);

763

rpc_clnt_remove_pipedir(clnt);

764

rpc_unregister_client(clnt);

764

rpc_unregister_client(clnt);

765

rpc_free_iostats(clnt->cl_metrics);

765

rpc_free_iostats(clnt->cl_metrics);

766

clnt->cl_metrics = NULL;

766

clnt->cl_metrics = NULL;

767

xprt_put(rcu_dereference_raw(clnt->cl_xprt));

767

xprt_put(rcu_dereference_raw(clnt->cl_xprt));

768

rpciod_down();

768

rpciod_down();

769

rpc_free_clid(clnt);

769

rpc_free_clid(clnt);

770

kfree(clnt);

770

kfree(clnt);

771

return parent;

771

return parent;

772

}

772

}

773

774

/*

774

/*

775

* Free an RPC client

775

* Free an RPC client

776

*/

776

*/

777

static struct rpc_clnt *

777

static struct rpc_clnt *

778

rpc_free_auth(struct rpc_clnt *clnt)

778

rpc_free_auth(struct rpc_clnt *clnt)

779

{

779

{

780

if (clnt->cl_auth == NULL)

780

if (clnt->cl_auth == NULL)

781

return rpc_free_client(clnt);

781

return rpc_free_client(clnt);

782

783

/*

783

/*

784

* Note: RPCSEC_GSS may need to send NULL RPC calls in order to

784

* Note: RPCSEC_GSS may need to send NULL RPC calls in order to

785

* release remaining GSS contexts. This mechanism ensures

785

* release remaining GSS contexts. This mechanism ensures

786

* that it can do so safely.

786

* that it can do so safely.

787

*/

787

*/

788

atomic_inc(&clnt->cl_count);

788

atomic_inc(&clnt->cl_count);

789

rpcauth_release(clnt->cl_auth);

789

rpcauth_release(clnt->cl_auth);

790

clnt->cl_auth = NULL;

790

clnt->cl_auth = NULL;

791

if (atomic_dec_and_test(&clnt->cl_count))

791

if (atomic_dec_and_test(&clnt->cl_count))

792

return rpc_free_client(clnt);

792

return rpc_free_client(clnt);

793

return NULL;

793

return NULL;

794

}

794

}

795

796

/*

796

/*

797

* Release reference to the RPC client

797

* Release reference to the RPC client

798

*/

798

*/

799

void

799

void

800

rpc_release_client(struct rpc_clnt *clnt)

800

rpc_release_client(struct rpc_clnt *clnt)

801

{

801

{

802

dprintk("RPC: rpc_release_client(%p)\n", clnt);

802

dprintk("RPC: rpc_release_client(%p)\n", clnt);

803

804

do {

804

do {

805

if (list_empty(&clnt->cl_tasks))

805

if (list_empty(&clnt->cl_tasks))

806

wake_up(&destroy_wait);

806

wake_up(&destroy_wait);

807

if (!atomic_dec_and_test(&clnt->cl_count))

807

if (!atomic_dec_and_test(&clnt->cl_count))

808

break;

808

break;

809

clnt = rpc_free_auth(clnt);

809

clnt = rpc_free_auth(clnt);

810

} while (clnt != NULL);

810

} while (clnt != NULL);

811

}

811

}

812

EXPORT_SYMBOL_GPL(rpc_release_client);

812

EXPORT_SYMBOL_GPL(rpc_release_client);

813

814

/**

814

/**

815

* rpc_bind_new_program - bind a new RPC program to an existing client

815

* rpc_bind_new_program - bind a new RPC program to an existing client

816

* @old: old rpc_client

816

* @old: old rpc_client

817

* @program: rpc program to set

817

* @program: rpc program to set

818

* @vers: rpc program version

818

* @vers: rpc program version

819

*

819

*

820

* Clones the rpc client and sets up a new RPC program. This is mainly

820

* Clones the rpc client and sets up a new RPC program. This is mainly

821

* of use for enabling different RPC programs to share the same transport.

821

* of use for enabling different RPC programs to share the same transport.

822

* The Sun NFSv2/v3 ACL protocol can do this.

822

* The Sun NFSv2/v3 ACL protocol can do this.

823

*/

823

*/

824

struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,

824

struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,

825

const struct rpc_program *program,

825

const struct rpc_program *program,

826

u32 vers)

826

u32 vers)

827

{

827

{

828

struct rpc_create_args args = {

828

struct rpc_create_args args = {

829

.program = program,

829

.program = program,

830

.prognumber = program->number,

830

.prognumber = program->number,

831

.version = vers,

831

.version = vers,

832

.authflavor = old->cl_auth->au_flavor,

832

.authflavor = old->cl_auth->au_flavor,

833

};

833

};

834

struct rpc_clnt *clnt;

834

struct rpc_clnt *clnt;

835

int err;

835

int err;

836

837

clnt = __rpc_clone_client(&args, old);

837

clnt = __rpc_clone_client(&args, old);

838

if (IS_ERR(clnt))

838

if (IS_ERR(clnt))

839

goto out;

839

goto out;

840

err = rpc_ping(clnt);

840

err = rpc_ping(clnt);

841

if (err != 0) {

841

if (err != 0) {

842

rpc_shutdown_client(clnt);

842

rpc_shutdown_client(clnt);

843

clnt = ERR_PTR(err);

843

clnt = ERR_PTR(err);

844

}

844

}

845

out:

845

out:

846

return clnt;

846

return clnt;

847

}

847

}

848

EXPORT_SYMBOL_GPL(rpc_bind_new_program);

848

EXPORT_SYMBOL_GPL(rpc_bind_new_program);

849

850

void rpc_task_release_client(struct rpc_task *task)

850

void rpc_task_release_client(struct rpc_task *task)

851

{

851

{

852

struct rpc_clnt *clnt = task->tk_client;

852

struct rpc_clnt *clnt = task->tk_client;

853

854

if (clnt != NULL) {

854

if (clnt != NULL) {

855

/* Remove from client task list */

855

/* Remove from client task list */

856

spin_lock(&clnt->cl_lock);

856

spin_lock(&clnt->cl_lock);

857

list_del(&task->tk_task);

857

list_del(&task->tk_task);

858

spin_unlock(&clnt->cl_lock);

858

spin_unlock(&clnt->cl_lock);

859

task->tk_client = NULL;

859

task->tk_client = NULL;

860

861

rpc_release_client(clnt);

861

rpc_release_client(clnt);

862

}

862

}

863

}

863

}

864

865

static

865

static

866

void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)

866

void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)

867

{

867

{

868

if (clnt != NULL) {

868

if (clnt != NULL) {

869

rpc_task_release_client(task);

869

rpc_task_release_client(task);

870

task->tk_client = clnt;

870

task->tk_client = clnt;

871

atomic_inc(&clnt->cl_count);

871

atomic_inc(&clnt->cl_count);

872

if (clnt->cl_softrtry)

872

if (clnt->cl_softrtry)

873

task->tk_flags |= RPC_TASK_SOFT;

873

task->tk_flags |= RPC_TASK_SOFT;

874

if (clnt->cl_noretranstimeo)

874

if (clnt->cl_noretranstimeo)

875

task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;

875

task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;

876

if (sk_memalloc_socks()) {

876

if (sk_memalloc_socks()) {

877

struct rpc_xprt *xprt;

877

struct rpc_xprt *xprt;

878

879

rcu_read_lock();

879

rcu_read_lock();

880

xprt = rcu_dereference(clnt->cl_xprt);

880

xprt = rcu_dereference(clnt->cl_xprt);

881

if (xprt->swapper)

881

if (xprt->swapper)

882

task->tk_flags |= RPC_TASK_SWAPPER;

882

task->tk_flags |= RPC_TASK_SWAPPER;

883

rcu_read_unlock();

883

rcu_read_unlock();

884

}

884

}

885

/* Add to the client's list of all tasks */

885

/* Add to the client's list of all tasks */

886

spin_lock(&clnt->cl_lock);

886

spin_lock(&clnt->cl_lock);

887

list_add_tail(&task->tk_task, &clnt->cl_tasks);

887

list_add_tail(&task->tk_task, &clnt->cl_tasks);

888

spin_unlock(&clnt->cl_lock);

888

spin_unlock(&clnt->cl_lock);

889

}

889

}

890

}

890

}

891

892

void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt)

892

void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt)

893

{

893

{

894

rpc_task_release_client(task);

894

rpc_task_release_client(task);

895

rpc_task_set_client(task, clnt);

895

rpc_task_set_client(task, clnt);

896

}

896

}

897

EXPORT_SYMBOL_GPL(rpc_task_reset_client);

897

EXPORT_SYMBOL_GPL(rpc_task_reset_client);

898

899

900

static void

900

static void

901

rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)

901

rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)

902

{

902

{

903

if (msg != NULL) {

903

if (msg != NULL) {

904

task->tk_msg.rpc_proc = msg->rpc_proc;

904

task->tk_msg.rpc_proc = msg->rpc_proc;

905

task->tk_msg.rpc_argp = msg->rpc_argp;

905

task->tk_msg.rpc_argp = msg->rpc_argp;

906

task->tk_msg.rpc_resp = msg->rpc_resp;

906

task->tk_msg.rpc_resp = msg->rpc_resp;

907

if (msg->rpc_cred != NULL)

907

if (msg->rpc_cred != NULL)

908

task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);

908

task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);

909

}

909

}

910

}

910

}

911

912

/*

912

/*

913

* Default callback for async RPC calls

913

* Default callback for async RPC calls

914

*/

914

*/

915

static void

915

static void

916

rpc_default_callback(struct rpc_task *task, void *data)

916

rpc_default_callback(struct rpc_task *task, void *data)

917

{

917

{

918

}

918

}

919

920

static const struct rpc_call_ops rpc_default_ops = {

920

static const struct rpc_call_ops rpc_default_ops = {

921

.rpc_call_done = rpc_default_callback,

921

.rpc_call_done = rpc_default_callback,

922

};

922

};

923

924

/**

924

/**

925

* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it

925

* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it

926

* @task_setup_data: pointer to task initialisation data

926

* @task_setup_data: pointer to task initialisation data

927

*/

927

*/

928

struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)

928

struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)

929

{

929

{

930

struct rpc_task *task;

930

struct rpc_task *task;

931

932

task = rpc_new_task(task_setup_data);

932

task = rpc_new_task(task_setup_data);

933

if (IS_ERR(task))

933

if (IS_ERR(task))

934

goto out;

934

goto out;

935

936

rpc_task_set_client(task, task_setup_data->rpc_client);

936

rpc_task_set_client(task, task_setup_data->rpc_client);

937

rpc_task_set_rpc_message(task, task_setup_data->rpc_message);

937

rpc_task_set_rpc_message(task, task_setup_data->rpc_message);

938

939

if (task->tk_action == NULL)

939

if (task->tk_action == NULL)

940

rpc_call_start(task);

940

rpc_call_start(task);

941

942

atomic_inc(&task->tk_count);

942

atomic_inc(&task->tk_count);

943

rpc_execute(task);

943

rpc_execute(task);

944

out:

944

out:

945

return task;

945

return task;

946

}

946

}

947

EXPORT_SYMBOL_GPL(rpc_run_task);

947

EXPORT_SYMBOL_GPL(rpc_run_task);

948

949

/**

949

/**

950

* rpc_call_sync - Perform a synchronous RPC call

950

* rpc_call_sync - Perform a synchronous RPC call

951

* @clnt: pointer to RPC client

951

* @clnt: pointer to RPC client

952

* @msg: RPC call parameters

952

* @msg: RPC call parameters

953

* @flags: RPC call flags

953

* @flags: RPC call flags

954

*/

954

*/

955

int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)

955

int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)

956

{

956

{

957

struct rpc_task *task;

957

struct rpc_task *task;

958

struct rpc_task_setup task_setup_data = {

958

struct rpc_task_setup task_setup_data = {

959

.rpc_client = clnt,

959

.rpc_client = clnt,

960

.rpc_message = msg,

960

.rpc_message = msg,

961

.callback_ops = &rpc_default_ops,

961

.callback_ops = &rpc_default_ops,

962

.flags = flags,

962

.flags = flags,

963

};

963

};

964

int status;

964

int status;

965

966

WARN_ON_ONCE(flags & RPC_TASK_ASYNC);

966

WARN_ON_ONCE(flags & RPC_TASK_ASYNC);

967

if (flags & RPC_TASK_ASYNC) {

967

if (flags & RPC_TASK_ASYNC) {

968

rpc_release_calldata(task_setup_data.callback_ops,

968

rpc_release_calldata(task_setup_data.callback_ops,

969

task_setup_data.callback_data);

969

task_setup_data.callback_data);

970

return -EINVAL;

970

return -EINVAL;

971

}

971

}

972

973

task = rpc_run_task(&task_setup_data);

973

task = rpc_run_task(&task_setup_data);

974

if (IS_ERR(task))

974

if (IS_ERR(task))

975

return PTR_ERR(task);

975

return PTR_ERR(task);

976

status = task->tk_status;

976

status = task->tk_status;

977

rpc_put_task(task);

977

rpc_put_task(task);

978

return status;

978

return status;

979

}

979

}

980

EXPORT_SYMBOL_GPL(rpc_call_sync);

980

EXPORT_SYMBOL_GPL(rpc_call_sync);

981

982

/**

982

/**

983

* rpc_call_async - Perform an asynchronous RPC call

983

* rpc_call_async - Perform an asynchronous RPC call

984

* @clnt: pointer to RPC client

984

* @clnt: pointer to RPC client

985

* @msg: RPC call parameters

985

* @msg: RPC call parameters

986

* @flags: RPC call flags

986

* @flags: RPC call flags

987

* @tk_ops: RPC call ops

987

* @tk_ops: RPC call ops

988

* @data: user call data

988

* @data: user call data

989

*/

989

*/

990

int

990

int

991

rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,

991

rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,

992

const struct rpc_call_ops *tk_ops, void *data)

992

const struct rpc_call_ops *tk_ops, void *data)

993

{

993

{

994

struct rpc_task *task;

994

struct rpc_task *task;

995

struct rpc_task_setup task_setup_data = {

995

struct rpc_task_setup task_setup_data = {

996

.rpc_client = clnt,

996

.rpc_client = clnt,

997

.rpc_message = msg,

997

.rpc_message = msg,

998

.callback_ops = tk_ops,

998

.callback_ops = tk_ops,

999

.callback_data = data,

999

.callback_data = data,

1000

.flags = flags|RPC_TASK_ASYNC,

1000

.flags = flags|RPC_TASK_ASYNC,

1001

};

1001

};

1002

1003

task = rpc_run_task(&task_setup_data);

1003

task = rpc_run_task(&task_setup_data);

1004

if (IS_ERR(task))

1004

if (IS_ERR(task))

1005

return PTR_ERR(task);

1005

return PTR_ERR(task);

1006

rpc_put_task(task);

1006

rpc_put_task(task);

1007

return 0;

1007

return 0;

1008

}

1008

}

1009

EXPORT_SYMBOL_GPL(rpc_call_async);

1009

EXPORT_SYMBOL_GPL(rpc_call_async);

1010

1011

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

1011

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

1012

/**

1012

/**

1013

* rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run

1013

* rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run

1014

* rpc_execute against it

1014

* rpc_execute against it

1015

* @req: RPC request

1015

* @req: RPC request

1016

* @tk_ops: RPC call ops

1016

* @tk_ops: RPC call ops

1017

*/

1017

*/

1018

struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,

1018

struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,

1019

const struct rpc_call_ops *tk_ops)

1019

const struct rpc_call_ops *tk_ops)

1020

{

1020

{

1021

struct rpc_task *task;

1021

struct rpc_task *task;

1022

struct xdr_buf *xbufp = &req->rq_snd_buf;

1022

struct xdr_buf *xbufp = &req->rq_snd_buf;

1023

struct rpc_task_setup task_setup_data = {

1023

struct rpc_task_setup task_setup_data = {

1024

.callback_ops = tk_ops,

1024

.callback_ops = tk_ops,

1025

};

1025

};

1026

1027

dprintk("RPC: rpc_run_bc_task req= %p\n", req);

1027

dprintk("RPC: rpc_run_bc_task req= %p\n", req);

1028

/*

1028

/*

1029

* Create an rpc_task to send the data

1029

* Create an rpc_task to send the data

1030

*/

1030

*/

1031

task = rpc_new_task(&task_setup_data);

1031

task = rpc_new_task(&task_setup_data);

1032

if (IS_ERR(task)) {

1032

if (IS_ERR(task)) {

1033

xprt_free_bc_request(req);

1033

xprt_free_bc_request(req);

1034

goto out;

1034

goto out;

1035

}

1035

}

1036

task->tk_rqstp = req;

1036

task->tk_rqstp = req;

1037

1038

/*

1038

/*

1039

* Set up the xdr_buf length.

1039

* Set up the xdr_buf length.

1040

* This also indicates that the buffer is XDR encoded already.

1040

* This also indicates that the buffer is XDR encoded already.

1041

*/

1041

*/

1042

xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +

1042

xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +

1043

xbufp->tail[0].iov_len;

1043

xbufp->tail[0].iov_len;

1044

1045

task->tk_action = call_bc_transmit;

1045

task->tk_action = call_bc_transmit;

1046

atomic_inc(&task->tk_count);

1046

atomic_inc(&task->tk_count);

1047

WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);

1047

WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);

1048

rpc_execute(task);

1048

rpc_execute(task);

1049

1050

out:

1050

out:

1051

dprintk("RPC: rpc_run_bc_task: task= %p\n", task);

1051

dprintk("RPC: rpc_run_bc_task: task= %p\n", task);

1052

return task;

1052

return task;

1053

}

1053

}

1054

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

1054

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

1055

1056

void

1056

void

1057

rpc_call_start(struct rpc_task *task)

1057

rpc_call_start(struct rpc_task *task)

1058

{

1058

{

1059

task->tk_action = call_start;

1059

task->tk_action = call_start;

1060

}

1060

}

1061

EXPORT_SYMBOL_GPL(rpc_call_start);

1061

EXPORT_SYMBOL_GPL(rpc_call_start);

1062

1063

/**

1063

/**

1064

* rpc_peeraddr - extract remote peer address from clnt's xprt

1064

* rpc_peeraddr - extract remote peer address from clnt's xprt

1065

* @clnt: RPC client structure

1065

* @clnt: RPC client structure

1066

* @buf: target buffer

1066

* @buf: target buffer

1067

* @bufsize: length of target buffer

1067

* @bufsize: length of target buffer

1068

*

1068

*

1069

* Returns the number of bytes that are actually in the stored address.

1069

* Returns the number of bytes that are actually in the stored address.

1070

*/

1070

*/

1071

size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)

1071

size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)

1072

{

1072

{

1073

size_t bytes;

1073

size_t bytes;

1074

struct rpc_xprt *xprt;

1074

struct rpc_xprt *xprt;

1075

1076

rcu_read_lock();

1076

rcu_read_lock();

1077

xprt = rcu_dereference(clnt->cl_xprt);

1077

xprt = rcu_dereference(clnt->cl_xprt);

1078

1079

bytes = xprt->addrlen;

1079

bytes = xprt->addrlen;

1080

if (bytes > bufsize)

1080

if (bytes > bufsize)

1081

bytes = bufsize;

1081

bytes = bufsize;

1082

memcpy(buf, &xprt->addr, bytes);

1082

memcpy(buf, &xprt->addr, bytes);

1083

rcu_read_unlock();

1083

rcu_read_unlock();

1084

1085

return bytes;

1085

return bytes;

1086

}

1086

}

1087

EXPORT_SYMBOL_GPL(rpc_peeraddr);

1087

EXPORT_SYMBOL_GPL(rpc_peeraddr);

1088

1089

/**

1089

/**

1090

* rpc_peeraddr2str - return remote peer address in printable format

1090

* rpc_peeraddr2str - return remote peer address in printable format

1091

* @clnt: RPC client structure

1091

* @clnt: RPC client structure

1092

* @format: address format

1092

* @format: address format

1093

*

1093

*

1094

* NB: the lifetime of the memory referenced by the returned pointer is

1094

* NB: the lifetime of the memory referenced by the returned pointer is

1095

* the same as the rpc_xprt itself. As long as the caller uses this

1095

* the same as the rpc_xprt itself. As long as the caller uses this

1096

* pointer, it must hold the RCU read lock.

1096

* pointer, it must hold the RCU read lock.

1097

*/

1097

*/

1098

const char *rpc_peeraddr2str(struct rpc_clnt *clnt,

1098

const char *rpc_peeraddr2str(struct rpc_clnt *clnt,

1099

enum rpc_display_format_t format)

1099

enum rpc_display_format_t format)

1100

{

1100

{

1101

struct rpc_xprt *xprt;

1101

struct rpc_xprt *xprt;

1102

1103

xprt = rcu_dereference(clnt->cl_xprt);

1103

xprt = rcu_dereference(clnt->cl_xprt);

1104

1105

if (xprt->address_strings[format] != NULL)

1105

if (xprt->address_strings[format] != NULL)

1106

return xprt->address_strings[format];

1106

return xprt->address_strings[format];

1107

else

1107

else

1108

return "unprintable";

1108

return "unprintable";

1109

}

1109

}

1110

EXPORT_SYMBOL_GPL(rpc_peeraddr2str);

1110

EXPORT_SYMBOL_GPL(rpc_peeraddr2str);

1111

1112

static const struct sockaddr_in rpc_inaddr_loopback = {

1112

static const struct sockaddr_in rpc_inaddr_loopback = {

1113

.sin_family = AF_INET,

1113

.sin_family = AF_INET,

1114

.sin_addr.s_addr = htonl(INADDR_ANY),

1114

.sin_addr.s_addr = htonl(INADDR_ANY),

1115

};

1115

};

1116

1117

static const struct sockaddr_in6 rpc_in6addr_loopback = {

1117

static const struct sockaddr_in6 rpc_in6addr_loopback = {

1118

.sin6_family = AF_INET6,

1118

.sin6_family = AF_INET6,

1119

.sin6_addr = IN6ADDR_ANY_INIT,

1119

.sin6_addr = IN6ADDR_ANY_INIT,

1120

};

1120

};

1121

1122

/*

1122

/*

1123

* Try a getsockname() on a connected datagram socket. Using a

1123

* Try a getsockname() on a connected datagram socket. Using a

1124

* connected datagram socket prevents leaving a socket in TIME_WAIT.

1124

* connected datagram socket prevents leaving a socket in TIME_WAIT.

1125

* This conserves the ephemeral port number space.

1125

* This conserves the ephemeral port number space.

1126

*

1126

*

1127

* Returns zero and fills in "buf" if successful; otherwise, a

1127

* Returns zero and fills in "buf" if successful; otherwise, a

1128

* negative errno is returned.

1128

* negative errno is returned.

1129

*/

1129

*/

1130

static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,

1130

static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,

1131

struct sockaddr *buf, int buflen)

1131

struct sockaddr *buf, int buflen)

1132

{

1132

{

1133

struct socket *sock;

1133

struct socket *sock;

1134

int err;

1134

int err;

1135

1136

err = __sock_create(net, sap->sa_family,

1136

err = __sock_create(net, sap->sa_family,

1137

SOCK_DGRAM, IPPROTO_UDP, &sock, 1);

1137

SOCK_DGRAM, IPPROTO_UDP, &sock, 1);

1138

if (err < 0) {

1138

if (err < 0) {

1139

dprintk("RPC: can't create UDP socket (%d)\n", err);

1139

dprintk("RPC: can't create UDP socket (%d)\n", err);

1140

goto out;

1140

goto out;

1141

}

1141

}

1142

1143

switch (sap->sa_family) {

1143

switch (sap->sa_family) {

1144

case AF_INET:

1144

case AF_INET:

1145

err = kernel_bind(sock,

1145

err = kernel_bind(sock,

1146

(struct sockaddr *)&rpc_inaddr_loopback,

1146

(struct sockaddr *)&rpc_inaddr_loopback,

1147

sizeof(rpc_inaddr_loopback));

1147

sizeof(rpc_inaddr_loopback));

1148

break;

1148

break;

1149

case AF_INET6:

1149

case AF_INET6:

1150

err = kernel_bind(sock,

1150

err = kernel_bind(sock,

1151

(struct sockaddr *)&rpc_in6addr_loopback,

1151

(struct sockaddr *)&rpc_in6addr_loopback,

1152

sizeof(rpc_in6addr_loopback));

1152

sizeof(rpc_in6addr_loopback));

1153

break;

1153

break;

1154

default:

1154

default:

1155

err = -EAFNOSUPPORT;

1155

err = -EAFNOSUPPORT;

1156

goto out;

1156

goto out;

1157

}

1157

}

1158

if (err < 0) {

1158

if (err < 0) {

1159

dprintk("RPC: can't bind UDP socket (%d)\n", err);

1159

dprintk("RPC: can't bind UDP socket (%d)\n", err);

1160

goto out_release;

1160

goto out_release;

1161

}

1161

}

1162

1163

err = kernel_connect(sock, sap, salen, 0);

1163

err = kernel_connect(sock, sap, salen, 0);

1164

if (err < 0) {

1164

if (err < 0) {

1165

dprintk("RPC: can't connect UDP socket (%d)\n", err);

1165

dprintk("RPC: can't connect UDP socket (%d)\n", err);

1166

goto out_release;

1166

goto out_release;

1167

}

1167

}

1168

1169

err = kernel_getsockname(sock, buf, &buflen);

1169

err = kernel_getsockname(sock, buf, &buflen);

1170

if (err < 0) {

1170

if (err < 0) {

1171

dprintk("RPC: getsockname failed (%d)\n", err);

1171

dprintk("RPC: getsockname failed (%d)\n", err);

1172

goto out_release;

1172

goto out_release;

1173

}

1173

}

1174

1175

err = 0;

1175

err = 0;

1176

if (buf->sa_family == AF_INET6) {

1176

if (buf->sa_family == AF_INET6) {

1177

struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;

1177

struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;

1178

sin6->sin6_scope_id = 0;

1178

sin6->sin6_scope_id = 0;

1179

}

1179

}

1180

dprintk("RPC: %s succeeded\n", __func__);

1180

dprintk("RPC: %s succeeded\n", __func__);

1181

1182

out_release:

1182

out_release:

1183

sock_release(sock);

1183

sock_release(sock);

1184

out:

1184

out:

1185

return err;

1185

return err;

1186

}

1186

}

1187

1188

/*

1188

/*

1189

* Scraping a connected socket failed, so we don't have a useable

1189

* Scraping a connected socket failed, so we don't have a useable

1190

* local address. Fallback: generate an address that will prevent

1190

* local address. Fallback: generate an address that will prevent

1191

* the server from calling us back.

1191

* the server from calling us back.

1192

*

1192

*

1193

* Returns zero and fills in "buf" if successful; otherwise, a

1193

* Returns zero and fills in "buf" if successful; otherwise, a

1194

* negative errno is returned.

1194

* negative errno is returned.

1195

*/

1195

*/

1196

static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)

1196

static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)

1197

{

1197

{

1198

switch (family) {

1198

switch (family) {

1199

case AF_INET:

1199

case AF_INET:

1200

if (buflen < sizeof(rpc_inaddr_loopback))

1200

if (buflen < sizeof(rpc_inaddr_loopback))

1201

return -EINVAL;

1201

return -EINVAL;

1202

memcpy(buf, &rpc_inaddr_loopback,

1202

memcpy(buf, &rpc_inaddr_loopback,

1203

sizeof(rpc_inaddr_loopback));

1203

sizeof(rpc_inaddr_loopback));

1204

break;

1204

break;

1205

case AF_INET6:

1205

case AF_INET6:

1206

if (buflen < sizeof(rpc_in6addr_loopback))

1206

if (buflen < sizeof(rpc_in6addr_loopback))

1207

return -EINVAL;

1207

return -EINVAL;

1208

memcpy(buf, &rpc_in6addr_loopback,

1208

memcpy(buf, &rpc_in6addr_loopback,

1209

sizeof(rpc_in6addr_loopback));

1209

sizeof(rpc_in6addr_loopback));

1210

default:

1210

default:

1211

dprintk("RPC: %s: address family not supported\n",

1211

dprintk("RPC: %s: address family not supported\n",

1212

__func__);

1212

__func__);

1213

return -EAFNOSUPPORT;

1213

return -EAFNOSUPPORT;

1214

}

1214

}

1215

dprintk("RPC: %s: succeeded\n", __func__);

1215

dprintk("RPC: %s: succeeded\n", __func__);

1216

return 0;

1216

return 0;

1217

}

1217

}

1218

1219

/**

1219

/**

1220

* rpc_localaddr - discover local endpoint address for an RPC client

1220

* rpc_localaddr - discover local endpoint address for an RPC client

1221

* @clnt: RPC client structure

1221

* @clnt: RPC client structure

1222

* @buf: target buffer

1222

* @buf: target buffer

1223

* @buflen: size of target buffer, in bytes

1223

* @buflen: size of target buffer, in bytes

1224

*

1224

*

1225

* Returns zero and fills in "buf" and "buflen" if successful;

1225

* Returns zero and fills in "buf" and "buflen" if successful;

1226

* otherwise, a negative errno is returned.

1226

* otherwise, a negative errno is returned.

1227

*

1227

*

1228

* This works even if the underlying transport is not currently connected,

1228

* This works even if the underlying transport is not currently connected,

1229

* or if the upper layer never previously provided a source address.

1229

* or if the upper layer never previously provided a source address.

1230

*

1230

*

1231

* The result of this function call is transient: multiple calls in

1231

* The result of this function call is transient: multiple calls in

1232

* succession may give different results, depending on how local

1232

* succession may give different results, depending on how local

1233

* networking configuration changes over time.

1233

* networking configuration changes over time.

1234

*/

1234

*/

1235

int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)

1235

int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)

1236

{

1236

{

1237

struct sockaddr_storage address;

1237

struct sockaddr_storage address;

1238

struct sockaddr *sap = (struct sockaddr *)&address;

1238

struct sockaddr *sap = (struct sockaddr *)&address;

1239

struct rpc_xprt *xprt;

1239

struct rpc_xprt *xprt;

1240

struct net *net;

1240

struct net *net;

1241

size_t salen;

1241

size_t salen;

1242

int err;

1242

int err;

1243

1244

rcu_read_lock();

1244

rcu_read_lock();

1245

xprt = rcu_dereference(clnt->cl_xprt);

1245

xprt = rcu_dereference(clnt->cl_xprt);

1246

salen = xprt->addrlen;

1246

salen = xprt->addrlen;

1247

memcpy(sap, &xprt->addr, salen);

1247

memcpy(sap, &xprt->addr, salen);

1248

net = get_net(xprt->xprt_net);

1248

net = get_net(xprt->xprt_net);

1249

rcu_read_unlock();

1249

rcu_read_unlock();

1250

1251

rpc_set_port(sap, 0);

1251

rpc_set_port(sap, 0);

1252

err = rpc_sockname(net, sap, salen, buf, buflen);

1252

err = rpc_sockname(net, sap, salen, buf, buflen);

1253

put_net(net);

1253

put_net(net);

1254

if (err != 0)

1254

if (err != 0)

1255

/* Couldn't discover local address, return ANYADDR */

1255

/* Couldn't discover local address, return ANYADDR */

1256

return rpc_anyaddr(sap->sa_family, buf, buflen);

1256

return rpc_anyaddr(sap->sa_family, buf, buflen);

1257

return 0;

1257

return 0;

1258

}

1258

}

1259

EXPORT_SYMBOL_GPL(rpc_localaddr);

1259

EXPORT_SYMBOL_GPL(rpc_localaddr);

1260

1261

void

1261

void

1262

rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)

1262

rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)

1263

{

1263

{

1264

struct rpc_xprt *xprt;

1264

struct rpc_xprt *xprt;

1265

1266

rcu_read_lock();

1266

rcu_read_lock();

1267

xprt = rcu_dereference(clnt->cl_xprt);

1267

xprt = rcu_dereference(clnt->cl_xprt);

1268

if (xprt->ops->set_buffer_size)

1268

if (xprt->ops->set_buffer_size)

1269

xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);

1269

xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);

1270

rcu_read_unlock();

1270

rcu_read_unlock();

1271

}

1271

}

1272

EXPORT_SYMBOL_GPL(rpc_setbufsize);

1272

EXPORT_SYMBOL_GPL(rpc_setbufsize);

1273

1274

/**

1274

/**

1275

* rpc_protocol - Get transport protocol number for an RPC client

1275

* rpc_protocol - Get transport protocol number for an RPC client

1276

* @clnt: RPC client to query

1276

* @clnt: RPC client to query

1277

*

1277

*

1278

*/

1278

*/

1279

int rpc_protocol(struct rpc_clnt *clnt)

1279

int rpc_protocol(struct rpc_clnt *clnt)

1280

{

1280

{

1281

int protocol;

1281

int protocol;

1282

1283

rcu_read_lock();

1283

rcu_read_lock();

1284

protocol = rcu_dereference(clnt->cl_xprt)->prot;

1284

protocol = rcu_dereference(clnt->cl_xprt)->prot;

1285

rcu_read_unlock();

1285

rcu_read_unlock();

1286

return protocol;

1286

return protocol;

1287

}

1287

}

1288

EXPORT_SYMBOL_GPL(rpc_protocol);

1288

EXPORT_SYMBOL_GPL(rpc_protocol);

1289

1290

/**

1290

/**

1291

* rpc_net_ns - Get the network namespace for this RPC client

1291

* rpc_net_ns - Get the network namespace for this RPC client

1292

* @clnt: RPC client to query

1292

* @clnt: RPC client to query

1293

*

1293

*

1294

*/

1294

*/

1295

struct net *rpc_net_ns(struct rpc_clnt *clnt)

1295

struct net *rpc_net_ns(struct rpc_clnt *clnt)

1296

{

1296

{

1297

struct net *ret;

1297

struct net *ret;

1298

1299

rcu_read_lock();

1299

rcu_read_lock();

1300

ret = rcu_dereference(clnt->cl_xprt)->xprt_net;

1300

ret = rcu_dereference(clnt->cl_xprt)->xprt_net;

1301

rcu_read_unlock();

1301

rcu_read_unlock();

1302

return ret;

1302

return ret;

1303

}

1303

}

1304

EXPORT_SYMBOL_GPL(rpc_net_ns);

1304

EXPORT_SYMBOL_GPL(rpc_net_ns);

1305

1306

/**

1306

/**

1307

* rpc_max_payload - Get maximum payload size for a transport, in bytes

1307

* rpc_max_payload - Get maximum payload size for a transport, in bytes

1308

* @clnt: RPC client to query

1308

* @clnt: RPC client to query

1309

*

1309

*

1310

* For stream transports, this is one RPC record fragment (see RFC

1310

* For stream transports, this is one RPC record fragment (see RFC

1311

* 1831), as we don't support multi-record requests yet. For datagram

1311

* 1831), as we don't support multi-record requests yet. For datagram

1312

* transports, this is the size of an IP packet minus the IP, UDP, and

1312

* transports, this is the size of an IP packet minus the IP, UDP, and

1313

* RPC header sizes.

1313

* RPC header sizes.

1314

*/

1314

*/

1315

size_t rpc_max_payload(struct rpc_clnt *clnt)

1315

size_t rpc_max_payload(struct rpc_clnt *clnt)

1316

{

1316

{

1317

size_t ret;

1317

size_t ret;

1318

1319

rcu_read_lock();

1319

rcu_read_lock();

1320

ret = rcu_dereference(clnt->cl_xprt)->max_payload;

1320

ret = rcu_dereference(clnt->cl_xprt)->max_payload;

1321

rcu_read_unlock();

1321

rcu_read_unlock();

1322

return ret;

1322

return ret;

1323

}

1323

}

1324

EXPORT_SYMBOL_GPL(rpc_max_payload);

1324

EXPORT_SYMBOL_GPL(rpc_max_payload);

1325

1326

/**

1326

/**

1327

* rpc_get_timeout - Get timeout for transport in units of HZ

1327

* rpc_get_timeout - Get timeout for transport in units of HZ

1328

* @clnt: RPC client to query

1328

* @clnt: RPC client to query

1329

*/

1329

*/

1330

unsigned long rpc_get_timeout(struct rpc_clnt *clnt)

1330

unsigned long rpc_get_timeout(struct rpc_clnt *clnt)

1331

{

1331

{

1332

unsigned long ret;

1332

unsigned long ret;

1333

1334

rcu_read_lock();

1334

rcu_read_lock();

1335

ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;

1335

ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;

1336

rcu_read_unlock();

1336

rcu_read_unlock();

1337

return ret;

1337

return ret;

1338

}

1338

}

1339

EXPORT_SYMBOL_GPL(rpc_get_timeout);

1339

EXPORT_SYMBOL_GPL(rpc_get_timeout);

1340

1341

/**

1341

/**

1342

* rpc_force_rebind - force transport to check that remote port is unchanged

1342

* rpc_force_rebind - force transport to check that remote port is unchanged

1343

* @clnt: client to rebind

1343

* @clnt: client to rebind

1344

*

1344

*

1345

*/

1345

*/

1346

void rpc_force_rebind(struct rpc_clnt *clnt)

1346

void rpc_force_rebind(struct rpc_clnt *clnt)

1347

{

1347

{

1348

if (clnt->cl_autobind) {

1348

if (clnt->cl_autobind) {

1349

rcu_read_lock();

1349

rcu_read_lock();

1350

xprt_clear_bound(rcu_dereference(clnt->cl_xprt));

1350

xprt_clear_bound(rcu_dereference(clnt->cl_xprt));

1351

rcu_read_unlock();

1351

rcu_read_unlock();

1352

}

1352

}

1353

}

1353

}

1354

EXPORT_SYMBOL_GPL(rpc_force_rebind);

1354

EXPORT_SYMBOL_GPL(rpc_force_rebind);

1355

1356

/*

1356

/*

1357

* Restart an (async) RPC call from the call_prepare state.

1357

* Restart an (async) RPC call from the call_prepare state.

1358

* Usually called from within the exit handler.

1358

* Usually called from within the exit handler.

1359

*/

1359

*/

1360

int

1360

int

1361

rpc_restart_call_prepare(struct rpc_task *task)

1361

rpc_restart_call_prepare(struct rpc_task *task)

1362

{

1362

{

1363

if (RPC_ASSASSINATED(task))

1363

if (RPC_ASSASSINATED(task))

1364

return 0;

1364

return 0;

1365

task->tk_action = call_start;

1365

task->tk_action = call_start;

1366

if (task->tk_ops->rpc_call_prepare != NULL)

1366

if (task->tk_ops->rpc_call_prepare != NULL)

1367

task->tk_action = rpc_prepare_task;

1367

task->tk_action = rpc_prepare_task;

1368

return 1;

1368

return 1;

1369

}

1369

}

1370

EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);

1370

EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);

1371

1372

/*

1372

/*

1373

* Restart an (async) RPC call. Usually called from within the

1373

* Restart an (async) RPC call. Usually called from within the

1374

* exit handler.

1374

* exit handler.

1375

*/

1375

*/

1376

int

1376

int

1377

rpc_restart_call(struct rpc_task *task)

1377

rpc_restart_call(struct rpc_task *task)

1378

{

1378

{

1379

if (RPC_ASSASSINATED(task))

1379

if (RPC_ASSASSINATED(task))

1380

return 0;

1380

return 0;

1381

task->tk_action = call_start;

1381

task->tk_action = call_start;

1382

return 1;

1382

return 1;

1383

}

1383

}

1384

EXPORT_SYMBOL_GPL(rpc_restart_call);

1384

EXPORT_SYMBOL_GPL(rpc_restart_call);

1385

1386

#ifdef RPC_DEBUG

1386

#ifdef RPC_DEBUG

1387

static const char *rpc_proc_name(const struct rpc_task *task)

1387

static const char *rpc_proc_name(const struct rpc_task *task)

1388

{

1388

{

1389

const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;

1389

const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;

1390

1391

if (proc) {

1391

if (proc) {

1392

if (proc->p_name)

1392

if (proc->p_name)

1393

return proc->p_name;

1393

return proc->p_name;

1394

else

1394

else

1395

return "NULL";

1395

return "NULL";

1396

} else

1396

} else

1397

return "no proc";

1397

return "no proc";

1398

}

1398

}

1399

#endif

1399

#endif

1400

1401

/*

1401

/*

1402

* 0. Initial state

1402

* 0. Initial state

1403

*

1403

*

1404

* Other FSM states can be visited zero or more times, but

1404

* Other FSM states can be visited zero or more times, but

1405

* this state is visited exactly once for each RPC.

1405

* this state is visited exactly once for each RPC.

1406

*/

1406

*/

1407

static void

1407

static void

1408

call_start(struct rpc_task *task)

1408

call_start(struct rpc_task *task)

1409

{

1409

{

1410

struct rpc_clnt *clnt = task->tk_client;

1410

struct rpc_clnt *clnt = task->tk_client;

1411

1412

dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,

1412

dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,

1413

clnt->cl_program->name, clnt->cl_vers,

1413

clnt->cl_program->name, clnt->cl_vers,

1414

rpc_proc_name(task),

1414

rpc_proc_name(task),

1415

(RPC_IS_ASYNC(task) ? "async" : "sync"));

1415

(RPC_IS_ASYNC(task) ? "async" : "sync"));

1416

1417

/* Increment call count */

1417

/* Increment call count */

1418

task->tk_msg.rpc_proc->p_count++;

1418

task->tk_msg.rpc_proc->p_count++;

1419

clnt->cl_stats->rpccnt++;

1419

clnt->cl_stats->rpccnt++;

1420

task->tk_action = call_reserve;

1420

task->tk_action = call_reserve;

1421

}

1421

}

1422

1423

/*

1423

/*

1424

* 1. Reserve an RPC call slot

1424

* 1. Reserve an RPC call slot

1425

*/

1425

*/

1426

static void

1426

static void

1427

call_reserve(struct rpc_task *task)

1427

call_reserve(struct rpc_task *task)

1428

{

1428

{

1429

dprint_status(task);

1429

dprint_status(task);

1430

1431

task->tk_status = 0;

1431

task->tk_status = 0;

1432

task->tk_action = call_reserveresult;

1432

task->tk_action = call_reserveresult;

1433

xprt_reserve(task);

1433

xprt_reserve(task);

1434

}

1434

}

1435

1436

static void call_retry_reserve(struct rpc_task *task);

1436

static void call_retry_reserve(struct rpc_task *task);

1437

1438

/*

1438

/*

1439

* 1b. Grok the result of xprt_reserve()

1439

* 1b. Grok the result of xprt_reserve()

1440

*/

1440

*/

1441

static void

1441

static void

1442

call_reserveresult(struct rpc_task *task)

1442

call_reserveresult(struct rpc_task *task)

1443

{

1443

{

1444

int status = task->tk_status;

1444

int status = task->tk_status;

1445

1446

dprint_status(task);

1446

dprint_status(task);

1447

1448

/*

1448

/*

1449

* After a call to xprt_reserve(), we must have either

1449

* After a call to xprt_reserve(), we must have either

1450

* a request slot or else an error status.

1450

* a request slot or else an error status.

1451

*/

1451

*/

1452

task->tk_status = 0;

1452

task->tk_status = 0;

1453

if (status >= 0) {

1453

if (status >= 0) {

1454

if (task->tk_rqstp) {

1454

if (task->tk_rqstp) {

1455

task->tk_action = call_refresh;

1455

task->tk_action = call_refresh;

1456

return;

1456

return;

1457

}

1457

}

1458

1459

printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",

1459

printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",

1460

__func__, status);

1460

__func__, status);

1461

rpc_exit(task, -EIO);

1461

rpc_exit(task, -EIO);

1462

return;

1462

return;

1463

}

1463

}

1464

1465

/*

1465

/*

1466

* Even though there was an error, we may have acquired

1466

* Even though there was an error, we may have acquired

1467

* a request slot somehow. Make sure not to leak it.

1467

* a request slot somehow. Make sure not to leak it.

1468

*/

1468

*/

1469

if (task->tk_rqstp) {

1469

if (task->tk_rqstp) {

1470

printk(KERN_ERR "%s: status=%d, request allocated anyway\n",

1470

printk(KERN_ERR "%s: status=%d, request allocated anyway\n",

1471

__func__, status);

1471

__func__, status);

1472

xprt_release(task);

1472

xprt_release(task);

1473

}

1473

}

1474

1475

switch (status) {

1475

switch (status) {

1476

case -ENOMEM:

1476

case -ENOMEM:

1477

rpc_delay(task, HZ >> 2);

1477

rpc_delay(task, HZ >> 2);

1478

case -EAGAIN: /* woken up; retry */

1478

case -EAGAIN: /* woken up; retry */

1479

task->tk_action = call_retry_reserve;

1479

task->tk_action = call_retry_reserve;

1480

return;

1480

return;

1481

case -EIO: /* probably a shutdown */

1481

case -EIO: /* probably a shutdown */

1482

break;

1482

break;

1483

default:

1483

default:

1484

printk(KERN_ERR "%s: unrecognized error %d, exiting\n",

1484

printk(KERN_ERR "%s: unrecognized error %d, exiting\n",

1485

__func__, status);

1485

__func__, status);

1486

break;

1486

break;

1487

}

1487

}

1488

rpc_exit(task, status);

1488

rpc_exit(task, status);

1489

}

1489

}

1490

1491

/*

1491

/*

1492

* 1c. Retry reserving an RPC call slot

1492

* 1c. Retry reserving an RPC call slot

1493

*/

1493

*/

1494

static void

1494

static void

1495

call_retry_reserve(struct rpc_task *task)

1495

call_retry_reserve(struct rpc_task *task)

1496

{

1496

{

1497

dprint_status(task);

1497

dprint_status(task);

1498

1499

task->tk_status = 0;

1499

task->tk_status = 0;

1500

task->tk_action = call_reserveresult;

1500

task->tk_action = call_reserveresult;

1501

xprt_retry_reserve(task);

1501

xprt_retry_reserve(task);

1502

}

1502

}

1503

1504

/*

1504

/*

1505

* 2. Bind and/or refresh the credentials

1505

* 2. Bind and/or refresh the credentials

1506

*/

1506

*/

1507

static void

1507

static void

1508

call_refresh(struct rpc_task *task)

1508

call_refresh(struct rpc_task *task)

1509

{

1509

{

1510

dprint_status(task);

1510

dprint_status(task);

1511

1512

task->tk_action = call_refreshresult;

1512

task->tk_action = call_refreshresult;

1513

task->tk_status = 0;

1513

task->tk_status = 0;

1514

task->tk_client->cl_stats->rpcauthrefresh++;

1514

task->tk_client->cl_stats->rpcauthrefresh++;

1515

rpcauth_refreshcred(task);

1515

rpcauth_refreshcred(task);

1516

}

1516

}

1517

1518

/*

1518

/*

1519

* 2a. Process the results of a credential refresh

1519

* 2a. Process the results of a credential refresh

1520

*/

1520

*/

1521

static void

1521

static void

1522

call_refreshresult(struct rpc_task *task)

1522

call_refreshresult(struct rpc_task *task)

1523

{

1523

{

1524

int status = task->tk_status;

1524

int status = task->tk_status;

1525

1526

dprint_status(task);

1526

dprint_status(task);

1527

1528

task->tk_status = 0;

1528

task->tk_status = 0;

1529

task->tk_action = call_refresh;

1529

task->tk_action = call_refresh;

1530

switch (status) {

1530

switch (status) {

1531

case 0:

1531

case 0:

1532

if (rpcauth_uptodatecred(task)) {

1532

if (rpcauth_uptodatecred(task)) {

1533

task->tk_action = call_allocate;

1533

task->tk_action = call_allocate;

1534

return;

1534

return;

1535

}

1535

}

1536

/* Use rate-limiting and a max number of retries if refresh

1536

/* Use rate-limiting and a max number of retries if refresh

1537

* had status 0 but failed to update the cred.

1537

* had status 0 but failed to update the cred.

1538

*/

1538

*/

1539

case -ETIMEDOUT:

1539

case -ETIMEDOUT:

1540

rpc_delay(task, 3*HZ);

1540

rpc_delay(task, 3*HZ);

1541

case -EAGAIN:

1541

case -EAGAIN:

1542

status = -EACCES;

1542

status = -EACCES;

1543

case -EKEYEXPIRED:

1543

case -EKEYEXPIRED:

1544

if (!task->tk_cred_retry)

1544

if (!task->tk_cred_retry)

1545

break;

1545

break;

1546

task->tk_cred_retry--;

1546

task->tk_cred_retry--;

1547

dprintk("RPC: %5u %s: retry refresh creds\n",

1547

dprintk("RPC: %5u %s: retry refresh creds\n",

1548

task->tk_pid, __func__);

1548

task->tk_pid, __func__);

1549

return;

1549

return;

1550

}

1550

}

1551

dprintk("RPC: %5u %s: refresh creds failed with error %d\n",

1551

dprintk("RPC: %5u %s: refresh creds failed with error %d\n",

1552

task->tk_pid, __func__, status);

1552

task->tk_pid, __func__, status);

1553

rpc_exit(task, status);

1553

rpc_exit(task, status);

1554

}

1554

}

1555

1556

/*

1556

/*

1557

* 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.

1557

* 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.

1558

* (Note: buffer memory is freed in xprt_release).

1558

* (Note: buffer memory is freed in xprt_release).

1559

*/

1559

*/

1560

static void

1560

static void

1561

call_allocate(struct rpc_task *task)

1561

call_allocate(struct rpc_task *task)

1562

{

1562

{

1563

unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;

1563

unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;

1564

struct rpc_rqst *req = task->tk_rqstp;

1564

struct rpc_rqst *req = task->tk_rqstp;

1565

struct rpc_xprt *xprt = req->rq_xprt;

1565

struct rpc_xprt *xprt = req->rq_xprt;

1566

struct rpc_procinfo *proc = task->tk_msg.rpc_proc;

1566

struct rpc_procinfo *proc = task->tk_msg.rpc_proc;

1567

1568

dprint_status(task);

1568

dprint_status(task);

1569

1570

task->tk_status = 0;

1570

task->tk_status = 0;

1571

task->tk_action = call_bind;

1571

task->tk_action = call_bind;

1572

1573

if (req->rq_buffer)

1573

if (req->rq_buffer)

1574

return;

1574

return;

1575

1576

if (proc->p_proc != 0) {

1576

if (proc->p_proc != 0) {

1577

BUG_ON(proc->p_arglen == 0);

1577

BUG_ON(proc->p_arglen == 0);

1578

if (proc->p_decode != NULL)

1578

if (proc->p_decode != NULL)

1579

BUG_ON(proc->p_replen == 0);

1579

BUG_ON(proc->p_replen == 0);

1580

}

1580

}

1581

1582

/*

1582

/*

1583

* Calculate the size (in quads) of the RPC call

1583

* Calculate the size (in quads) of the RPC call

1584

* and reply headers, and convert both values

1584

* and reply headers, and convert both values

1585

* to byte sizes.

1585

* to byte sizes.

1586

*/

1586

*/

1587

req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;

1587

req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;

1588

req->rq_callsize <<= 2;

1588

req->rq_callsize <<= 2;

1589

req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;

1589

req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;

1590

req->rq_rcvsize <<= 2;

1590

req->rq_rcvsize <<= 2;

1591

1592

req->rq_buffer = xprt->ops->buf_alloc(task,

1592

req->rq_buffer = xprt->ops->buf_alloc(task,

1593

req->rq_callsize + req->rq_rcvsize);

1593

req->rq_callsize + req->rq_rcvsize);

1594

if (req->rq_buffer != NULL)

1594

if (req->rq_buffer != NULL)

1595

return;

1595

return;

1596

1597

dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);

1597

dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);

1598

1599

if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {

1599

if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {

1600

task->tk_action = call_allocate;

1600

task->tk_action = call_allocate;

1601

rpc_delay(task, HZ>>4);

1601

rpc_delay(task, HZ>>4);

1602

return;

1602

return;

1603

}

1603

}

1604

1605

rpc_exit(task, -ERESTARTSYS);

1605

rpc_exit(task, -ERESTARTSYS);

1606

}

1606

}

1607

1608

static inline int

1608

static inline int

1609

rpc_task_need_encode(struct rpc_task *task)

1609

rpc_task_need_encode(struct rpc_task *task)

1610

{

1610

{

1611

return task->tk_rqstp->rq_snd_buf.len == 0;

1611

return task->tk_rqstp->rq_snd_buf.len == 0;

1612

}

1612

}

1613

1614

static inline void

1614

static inline void

1615

rpc_task_force_reencode(struct rpc_task *task)

1615

rpc_task_force_reencode(struct rpc_task *task)

1616

{

1616

{

1617

task->tk_rqstp->rq_snd_buf.len = 0;

1617

task->tk_rqstp->rq_snd_buf.len = 0;

1618

task->tk_rqstp->rq_bytes_sent = 0;

1618

task->tk_rqstp->rq_bytes_sent = 0;

1619

}

1619

}

1620

1621

static inline void

1621

static inline void

1622

rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)

1622

rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)

1623

{

1623

{

1624

buf->head[0].iov_base = start;

1624

buf->head[0].iov_base = start;

1625

buf->head[0].iov_len = len;

1625

buf->head[0].iov_len = len;

1626

buf->tail[0].iov_len = 0;

1626

buf->tail[0].iov_len = 0;

1627

buf->page_len = 0;

1627

buf->page_len = 0;

1628

buf->flags = 0;

1628

buf->flags = 0;

1629

buf->len = 0;

1629

buf->len = 0;

1630

buf->buflen = len;

1630

buf->buflen = len;

1631

}

1631

}

1632

1633

/*

1633

/*

1634

* 3. Encode arguments of an RPC call

1634

* 3. Encode arguments of an RPC call

1635

*/

1635

*/

1636

static void

1636

static void

1637

rpc_xdr_encode(struct rpc_task *task)

1637

rpc_xdr_encode(struct rpc_task *task)

1638

{

1638

{

1639

struct rpc_rqst *req = task->tk_rqstp;

1639

struct rpc_rqst *req = task->tk_rqstp;

1640

kxdreproc_t encode;

1640

kxdreproc_t encode;

1641

__be32 *p;

1641

__be32 *p;

1642

1643

dprint_status(task);

1643

dprint_status(task);

1644

1645

rpc_xdr_buf_init(&req->rq_snd_buf,

1645

rpc_xdr_buf_init(&req->rq_snd_buf,

1646

req->rq_buffer,

1646

req->rq_buffer,

1647

req->rq_callsize);

1647

req->rq_callsize);

1648

rpc_xdr_buf_init(&req->rq_rcv_buf,

1648

rpc_xdr_buf_init(&req->rq_rcv_buf,

1649

(char *)req->rq_buffer + req->rq_callsize,

1649

(char *)req->rq_buffer + req->rq_callsize,

1650

req->rq_rcvsize);

1650

req->rq_rcvsize);

1651

1652

p = rpc_encode_header(task);

1652

p = rpc_encode_header(task);

1653

if (p == NULL) {

1653

if (p == NULL) {

1654

printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");

1654

printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");

1655

rpc_exit(task, -EIO);

1655

rpc_exit(task, -EIO);

1656

return;

1656

return;

1657

}

1657

}

1658

1659

encode = task->tk_msg.rpc_proc->p_encode;

1659

encode = task->tk_msg.rpc_proc->p_encode;

1660

if (encode == NULL)

1660

if (encode == NULL)

1661

return;

1661

return;

1662

1663

task->tk_status = rpcauth_wrap_req(task, encode, req, p,

1663

task->tk_status = rpcauth_wrap_req(task, encode, req, p,

1664

task->tk_msg.rpc_argp);

1664

task->tk_msg.rpc_argp);

1665

}

1665

}

1666

1667

/*

1667

/*

1668

* 4. Get the server port number if not yet set

1668

* 4. Get the server port number if not yet set

1669

*/

1669

*/

1670

static void

1670

static void

1671

call_bind(struct rpc_task *task)

1671

call_bind(struct rpc_task *task)

1672

{

1672

{

1673

struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;

1673

struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;

1674

1675

dprint_status(task);

1675

dprint_status(task);

1676

1677

task->tk_action = call_connect;

1677

task->tk_action = call_connect;

1678

if (!xprt_bound(xprt)) {

1678

if (!xprt_bound(xprt)) {

1679

task->tk_action = call_bind_status;

1679

task->tk_action = call_bind_status;

1680

task->tk_timeout = xprt->bind_timeout;

1680

task->tk_timeout = xprt->bind_timeout;

1681

xprt->ops->rpcbind(task);

1681

xprt->ops->rpcbind(task);

1682

}

1682

}

1683

}

1683

}

1684

1685

/*

1685

/*

1686

* 4a. Sort out bind result

1686

* 4a. Sort out bind result

1687

*/

1687

*/

1688

static void

1688

static void

1689

call_bind_status(struct rpc_task *task)

1689

call_bind_status(struct rpc_task *task)

1690

{

1690

{

1691

int status = -EIO;

1691

int status = -EIO;

1692

1693

if (task->tk_status >= 0) {

1693

if (task->tk_status >= 0) {

1694

dprint_status(task);

1694

dprint_status(task);

1695

task->tk_status = 0;

1695

task->tk_status = 0;

1696

task->tk_action = call_connect;

1696

task->tk_action = call_connect;

1697

return;

1697

return;

1698

}

1698

}

1699

1700

trace_rpc_bind_status(task);

1700

trace_rpc_bind_status(task);

1701

switch (task->tk_status) {

1701

switch (task->tk_status) {

1702

case -ENOMEM:

1702

case -ENOMEM:

1703

dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);

1703

dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);

1704

rpc_delay(task, HZ >> 2);

1704

rpc_delay(task, HZ >> 2);

1705

goto retry_timeout;

1705

goto retry_timeout;

1706

case -EACCES:

1706

case -EACCES:

1707

dprintk("RPC: %5u remote rpcbind: RPC program/version "

1707

dprintk("RPC: %5u remote rpcbind: RPC program/version "

1708

"unavailable\n", task->tk_pid);

1708

"unavailable\n", task->tk_pid);

1709

/* fail immediately if this is an RPC ping */

1709

/* fail immediately if this is an RPC ping */

1710

if (task->tk_msg.rpc_proc->p_proc == 0) {

1710

if (task->tk_msg.rpc_proc->p_proc == 0) {

1711

status = -EOPNOTSUPP;

1711

status = -EOPNOTSUPP;

1712

break;

1712

break;

1713

}

1713

}

1714

if (task->tk_rebind_retry == 0)

1714

if (task->tk_rebind_retry == 0)

1715

break;

1715

break;

1716

task->tk_rebind_retry--;

1716

task->tk_rebind_retry--;

1717

rpc_delay(task, 3*HZ);

1717

rpc_delay(task, 3*HZ);

1718

goto retry_timeout;

1718

goto retry_timeout;

1719

case -ETIMEDOUT:

1719

case -ETIMEDOUT:

1720

dprintk("RPC: %5u rpcbind request timed out\n",

1720

dprintk("RPC: %5u rpcbind request timed out\n",

1721

task->tk_pid);

1721

task->tk_pid);

1722

goto retry_timeout;

1722

goto retry_timeout;

1723

case -EPFNOSUPPORT:

1723

case -EPFNOSUPPORT:

1724

/* server doesn't support any rpcbind version we know of */

1724

/* server doesn't support any rpcbind version we know of */

1725

dprintk("RPC: %5u unrecognized remote rpcbind service\n",

1725

dprintk("RPC: %5u unrecognized remote rpcbind service\n",

1726

task->tk_pid);

1726

task->tk_pid);

1727

break;

1727

break;

1728

case -EPROTONOSUPPORT:

1728

case -EPROTONOSUPPORT:

1729

dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",

1729

dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",

1730

task->tk_pid);

1730

task->tk_pid);

1731

task->tk_status = 0;

1731

task->tk_status = 0;

1732

task->tk_action = call_bind;

1732

task->tk_action = call_bind;

1733

return;

1733

return;

1734

case -ECONNREFUSED: /* connection problems */

1734

case -ECONNREFUSED: /* connection problems */

1735

case -ECONNRESET:

1735

case -ECONNRESET:

1736

case -ECONNABORTED:

1736

case -ECONNABORTED:

1737

case -ENOTCONN:

1737

case -ENOTCONN:

1738

case -EHOSTDOWN:

1738

case -EHOSTDOWN:

1739

case -EHOSTUNREACH:

1739

case -EHOSTUNREACH:

1740

case -ENETUNREACH:

1740

case -ENETUNREACH:

1741

case -EPIPE:

1741

case -EPIPE:

1742

dprintk("RPC: %5u remote rpcbind unreachable: %d\n",

1742

dprintk("RPC: %5u remote rpcbind unreachable: %d\n",

1743

task->tk_pid, task->tk_status);

1743

task->tk_pid, task->tk_status);

1744

if (!RPC_IS_SOFTCONN(task)) {

1744

if (!RPC_IS_SOFTCONN(task)) {

1745

rpc_delay(task, 5*HZ);

1745

rpc_delay(task, 5*HZ);

1746

goto retry_timeout;

1746

goto retry_timeout;

1747

}

1747

}

1748

status = task->tk_status;

1748

status = task->tk_status;

1749

break;

1749

break;

1750

default:

1750

default:

1751

dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",

1751

dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",

1752

task->tk_pid, -task->tk_status);

1752

task->tk_pid, -task->tk_status);

1753

}

1753

}

1754

1755

rpc_exit(task, status);

1755

rpc_exit(task, status);

1756

return;

1756

return;

1757

1758

retry_timeout:

1758

retry_timeout:

1759

task->tk_action = call_timeout;

1759

task->tk_action = call_timeout;

1760

}

1760

}

1761

1762

/*

1762

/*

1763

* 4b. Connect to the RPC server

1763

* 4b. Connect to the RPC server

1764

*/

1764

*/

1765

static void

1765

static void

1766

call_connect(struct rpc_task *task)

1766

call_connect(struct rpc_task *task)

1767

{

1767

{

1768

struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;

1768

struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;

1769

1770

dprintk("RPC: %5u call_connect xprt %p %s connected\n",

1770

dprintk("RPC: %5u call_connect xprt %p %s connected\n",

1771

task->tk_pid, xprt,

1771

task->tk_pid, xprt,

1772

(xprt_connected(xprt) ? "is" : "is not"));

1772

(xprt_connected(xprt) ? "is" : "is not"));

1773

1774

task->tk_action = call_transmit;

1774

task->tk_action = call_transmit;

1775

if (!xprt_connected(xprt)) {

1775

if (!xprt_connected(xprt)) {

1776

task->tk_action = call_connect_status;

1776

task->tk_action = call_connect_status;

1777

if (task->tk_status < 0)

1777

if (task->tk_status < 0)

1778

return;

1778

return;

1779

if (task->tk_flags & RPC_TASK_NOCONNECT) {

1779

if (task->tk_flags & RPC_TASK_NOCONNECT) {

1780

rpc_exit(task, -ENOTCONN);

1780

rpc_exit(task, -ENOTCONN);

1781

return;

1781

return;

1782

}

1782

}

1783

xprt_connect(task);

1783

xprt_connect(task);

1784

}

1784

}

1785

}

1785

}

1786

1787

/*

1787

/*

1788

* 4c. Sort out connect result

1788

* 4c. Sort out connect result

1789

*/

1789

*/

1790

static void

1790

static void

1791

call_connect_status(struct rpc_task *task)

1791

call_connect_status(struct rpc_task *task)

1792

{

1792

{

1793

struct rpc_clnt *clnt = task->tk_client;

1793

struct rpc_clnt *clnt = task->tk_client;

1794

int status = task->tk_status;

1794

int status = task->tk_status;

1795

1796

dprint_status(task);

1796

dprint_status(task);

1797

1798

trace_rpc_connect_status(task, status);

1798

trace_rpc_connect_status(task, status);

1799

task->tk_status = 0;

1799

task->tk_status = 0;

1800

switch (status) {

1800

switch (status) {

1801

case -ECONNREFUSED:

1801

case -ECONNREFUSED:

1802

case -ECONNRESET:

1802

case -ECONNRESET:

1803

case -ECONNABORTED:

1803

case -ECONNABORTED:

1804

case -ENETUNREACH:

1804

case -ENETUNREACH:

1805

case -EHOSTUNREACH:

1805

case -EHOSTUNREACH:

1806

/* retry with existing socket, after a delay */

1807

rpc_delay(task, 3*HZ);

1808

if (RPC_IS_SOFTCONN(task))

1806

if (RPC_IS_SOFTCONN(task))

1809

break;

1807

break;

1808

/* retry with existing socket, after a delay */

1809

rpc_delay(task, 3*HZ);

1810

case -EAGAIN:

1810

case -EAGAIN:

1811

/* Check for timeouts before looping back to call_bind */

1811

/* Check for timeouts before looping back to call_bind */

1812

case -ETIMEDOUT:

1812

case -ETIMEDOUT:

1813

task->tk_action = call_timeout;

1813

task->tk_action = call_timeout;

1814

return;

1814

return;

1815

case 0:

1815

case 0:

1816

clnt->cl_stats->netreconn++;

1816

clnt->cl_stats->netreconn++;

1817

task->tk_action = call_transmit;

1817

task->tk_action = call_transmit;

1818

return;

1818

return;

1819

}

1819

}

1820

rpc_exit(task, status);

1820

rpc_exit(task, status);

1821

}

1821

}

1822

1823

/*

1823

/*

1824

* 5. Transmit the RPC request, and wait for reply

1824

* 5. Transmit the RPC request, and wait for reply

1825

*/

1825

*/

1826

static void

1826

static void

1827

call_transmit(struct rpc_task *task)

1827

call_transmit(struct rpc_task *task)

1828

{

1828

{

1829

int is_retrans = RPC_WAS_SENT(task);

1829

int is_retrans = RPC_WAS_SENT(task);

1830

1831

dprint_status(task);

1831

dprint_status(task);

1832

1833

task->tk_action = call_status;

1833

task->tk_action = call_status;

1834

if (task->tk_status < 0)

1834

if (task->tk_status < 0)

1835

return;

1835

return;

1836

if (!xprt_prepare_transmit(task))

1836

if (!xprt_prepare_transmit(task))

1837

return;

1837

return;

1838

task->tk_action = call_transmit_status;

1838

task->tk_action = call_transmit_status;

1839

/* Encode here so that rpcsec_gss can use correct sequence number. */

1839

/* Encode here so that rpcsec_gss can use correct sequence number. */

1840

if (rpc_task_need_encode(task)) {

1840

if (rpc_task_need_encode(task)) {

1841

rpc_xdr_encode(task);

1841

rpc_xdr_encode(task);

1842

/* Did the encode result in an error condition? */

1842

/* Did the encode result in an error condition? */

1843

if (task->tk_status != 0) {

1843

if (task->tk_status != 0) {

1844

/* Was the error nonfatal? */

1844

/* Was the error nonfatal? */

1845

if (task->tk_status == -EAGAIN)

1845

if (task->tk_status == -EAGAIN)

1846

rpc_delay(task, HZ >> 4);

1846

rpc_delay(task, HZ >> 4);

1847

else

1847

else

1848

rpc_exit(task, task->tk_status);

1848

rpc_exit(task, task->tk_status);

1849

return;

1849

return;

1850

}

1850

}

1851

}

1851

}

1852

xprt_transmit(task);

1852

xprt_transmit(task);

1853

if (task->tk_status < 0)

1853

if (task->tk_status < 0)

1854

return;

1854

return;

1855

if (is_retrans)

1855

if (is_retrans)

1856

task->tk_client->cl_stats->rpcretrans++;

1856

task->tk_client->cl_stats->rpcretrans++;

1857

/*

1857

/*

1858

* On success, ensure that we call xprt_end_transmit() before sleeping

1858

* On success, ensure that we call xprt_end_transmit() before sleeping

1859

* in order to allow access to the socket to other RPC requests.

1859

* in order to allow access to the socket to other RPC requests.

1860

*/

1860

*/

1861

call_transmit_status(task);

1861

call_transmit_status(task);

1862

if (rpc_reply_expected(task))

1862

if (rpc_reply_expected(task))

1863

return;

1863

return;

1864

task->tk_action = rpc_exit_task;

1864

task->tk_action = rpc_exit_task;

1865

rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);

1865

rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);

1866

}

1866

}

1867

1868

/*

1868

/*

1869

* 5a. Handle cleanup after a transmission

1869

* 5a. Handle cleanup after a transmission

1870

*/

1870

*/

1871

static void

1871

static void

1872

call_transmit_status(struct rpc_task *task)

1872

call_transmit_status(struct rpc_task *task)

1873

{

1873

{

1874

task->tk_action = call_status;

1874

task->tk_action = call_status;

1875

1876

/*

1876

/*

1877

* Common case: success. Force the compiler to put this

1877

* Common case: success. Force the compiler to put this

1878

* test first.

1878

* test first.

1879

*/

1879

*/

1880

if (task->tk_status == 0) {

1880

if (task->tk_status == 0) {

1881

xprt_end_transmit(task);

1881

xprt_end_transmit(task);

1882

rpc_task_force_reencode(task);

1882

rpc_task_force_reencode(task);

1883

return;

1883

return;

1884

}

1884

}

1885

1886

switch (task->tk_status) {

1886

switch (task->tk_status) {

1887

case -EAGAIN:

1887

case -EAGAIN:

1888

break;

1888

break;

1889

default:

1889

default:

1890

dprint_status(task);

1890

dprint_status(task);

1891

xprt_end_transmit(task);

1891

xprt_end_transmit(task);

1892

rpc_task_force_reencode(task);

1892

rpc_task_force_reencode(task);

1893

break;

1893

break;

1894

/*

1894

/*

1895

* Special cases: if we've been waiting on the

1895

* Special cases: if we've been waiting on the

1896

* socket's write_space() callback, or if the

1896

* socket's write_space() callback, or if the

1897

* socket just returned a connection error,

1897

* socket just returned a connection error,

1898

* then hold onto the transport lock.

1898

* then hold onto the transport lock.

1899

*/

1899

*/

1900

case -ECONNREFUSED:

1900

case -ECONNREFUSED:

1901

case -EHOSTDOWN:

1901

case -EHOSTDOWN:

1902

case -EHOSTUNREACH:

1902

case -EHOSTUNREACH:

1903

case -ENETUNREACH:

1903

case -ENETUNREACH:

1904

if (RPC_IS_SOFTCONN(task)) {

1904

if (RPC_IS_SOFTCONN(task)) {

1905

xprt_end_transmit(task);

1905

xprt_end_transmit(task);

1906

rpc_exit(task, task->tk_status);

1906

rpc_exit(task, task->tk_status);

1907

break;

1907

break;

1908

}

1908

}

1909

case -ECONNRESET:

1909

case -ECONNRESET:

1910

case -ECONNABORTED:

1910

case -ECONNABORTED:

1911

case -ENOTCONN:

1911

case -ENOTCONN:

1912

case -EPIPE:

1912

case -EPIPE:

1913

rpc_task_force_reencode(task);

1913

rpc_task_force_reencode(task);

1914

}

1914

}

1915

}

1915

}

1916

1917

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

1917

#if defined(CONFIG_SUNRPC_BACKCHANNEL)

1918

/*

1918

/*

1919

* 5b. Send the backchannel RPC reply. On error, drop the reply. In

1919

* 5b. Send the backchannel RPC reply. On error, drop the reply. In

1920

* addition, disconnect on connectivity errors.

1920

* addition, disconnect on connectivity errors.

1921

*/

1921

*/

1922

static void

1922

static void

1923

call_bc_transmit(struct rpc_task *task)

1923

call_bc_transmit(struct rpc_task *task)

1924

{

1924

{

1925

struct rpc_rqst *req = task->tk_rqstp;

1925

struct rpc_rqst *req = task->tk_rqstp;

1926

1927

if (!xprt_prepare_transmit(task)) {

1927

if (!xprt_prepare_transmit(task)) {

1928

/*

1928

/*

1929

* Could not reserve the transport. Try again after the

1929

* Could not reserve the transport. Try again after the

1930

* transport is released.

1930

* transport is released.

1931

*/

1931

*/

1932

task->tk_status = 0;

1932

task->tk_status = 0;

1933

task->tk_action = call_bc_transmit;

1933

task->tk_action = call_bc_transmit;

1934

return;

1934

return;

1935

}

1935

}

1936

1937

task->tk_action = rpc_exit_task;

1937

task->tk_action = rpc_exit_task;

1938

if (task->tk_status < 0) {

1938

if (task->tk_status < 0) {

1939

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1939

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1940

"error: %d\n", task->tk_status);

1940

"error: %d\n", task->tk_status);

1941

return;

1941

return;

1942

}

1942

}

1943

1944

xprt_transmit(task);

1944

xprt_transmit(task);

1945

xprt_end_transmit(task);

1945

xprt_end_transmit(task);

1946

dprint_status(task);

1946

dprint_status(task);

1947

switch (task->tk_status) {

1947

switch (task->tk_status) {

1948

case 0:

1948

case 0:

1949

/* Success */

1949

/* Success */

1950

break;

1950

break;

1951

case -EHOSTDOWN:

1951

case -EHOSTDOWN:

1952

case -EHOSTUNREACH:

1952

case -EHOSTUNREACH:

1953

case -ENETUNREACH:

1953

case -ENETUNREACH:

1954

case -ETIMEDOUT:

1954

case -ETIMEDOUT:

1955

/*

1955

/*

1956

* Problem reaching the server. Disconnect and let the

1956

* Problem reaching the server. Disconnect and let the

1957

* forechannel reestablish the connection. The server will

1957

* forechannel reestablish the connection. The server will

1958

* have to retransmit the backchannel request and we'll

1958

* have to retransmit the backchannel request and we'll

1959

* reprocess it. Since these ops are idempotent, there's no

1959

* reprocess it. Since these ops are idempotent, there's no

1960

* need to cache our reply at this time.

1960

* need to cache our reply at this time.

1961

*/

1961

*/

1962

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1962

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1963

"error: %d\n", task->tk_status);

1963

"error: %d\n", task->tk_status);

1964

xprt_conditional_disconnect(req->rq_xprt,

1964

xprt_conditional_disconnect(req->rq_xprt,

1965

req->rq_connect_cookie);

1965

req->rq_connect_cookie);

1966

break;

1966

break;

1967

default:

1967

default:

1968

/*

1968

/*

1969

* We were unable to reply and will have to drop the

1969

* We were unable to reply and will have to drop the

1970

* request. The server should reconnect and retransmit.

1970

* request. The server should reconnect and retransmit.

1971

*/

1971

*/

1972

WARN_ON_ONCE(task->tk_status == -EAGAIN);

1972

WARN_ON_ONCE(task->tk_status == -EAGAIN);

1973

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1973

printk(KERN_NOTICE "RPC: Could not send backchannel reply "

1974

"error: %d\n", task->tk_status);

1974

"error: %d\n", task->tk_status);

1975

break;

1975

break;

1976

}

1976

}

1977

rpc_wake_up_queued_task(&req->rq_xprt->pending, task);

1977

rpc_wake_up_queued_task(&req->rq_xprt->pending, task);

1978

}

1978

}

1979

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

1979

#endif /* CONFIG_SUNRPC_BACKCHANNEL */

1980

1981

/*

1981

/*

1982

* 6. Sort out the RPC call status

1982

* 6. Sort out the RPC call status

1983

*/

1983

*/

1984

static void

1984

static void

1985

call_status(struct rpc_task *task)

1985

call_status(struct rpc_task *task)

1986

{

1986

{

1987

struct rpc_clnt *clnt = task->tk_client;

1987

struct rpc_clnt *clnt = task->tk_client;

1988

struct rpc_rqst *req = task->tk_rqstp;

1988

struct rpc_rqst *req = task->tk_rqstp;

1989

int status;

1989

int status;

1990

1991

if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)

1991

if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)

1992

task->tk_status = req->rq_reply_bytes_recvd;

1992

task->tk_status = req->rq_reply_bytes_recvd;

1993

1994

dprint_status(task);

1994

dprint_status(task);

1995

1996

status = task->tk_status;

1996

status = task->tk_status;

1997

if (status >= 0) {

1997

if (status >= 0) {

1998

task->tk_action = call_decode;

1998

task->tk_action = call_decode;

1999

return;

1999

return;

2000

}

2000

}

2001

2002

trace_rpc_call_status(task);

2002

trace_rpc_call_status(task);

2003

task->tk_status = 0;

2003

task->tk_status = 0;

2004

switch(status) {

2004

switch(status) {

2005

case -EHOSTDOWN:

2005

case -EHOSTDOWN:

2006

case -EHOSTUNREACH:

2006

case -EHOSTUNREACH:

2007

case -ENETUNREACH:

2007

case -ENETUNREACH:

2008

/*

2008

/*

2009

* Delay any retries for 3 seconds, then handle as if it

2009

* Delay any retries for 3 seconds, then handle as if it

2010

* were a timeout.

2010

* were a timeout.

2011

*/

2011

*/

2012

rpc_delay(task, 3*HZ);

2012

rpc_delay(task, 3*HZ);

2013

case -ETIMEDOUT:

2013

case -ETIMEDOUT:

2014

task->tk_action = call_timeout;

2014

task->tk_action = call_timeout;

2015

if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)

2015

if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)

2016

&& task->tk_client->cl_discrtry)

2016

&& task->tk_client->cl_discrtry)

2017

xprt_conditional_disconnect(req->rq_xprt,

2017

xprt_conditional_disconnect(req->rq_xprt,

2018

req->rq_connect_cookie);

2018

req->rq_connect_cookie);

2019

break;

2019

break;

2020

case -ECONNREFUSED:

2020

case -ECONNREFUSED:

2021

case -ECONNRESET:

2021

case -ECONNRESET:

2022

case -ECONNABORTED:

2022

case -ECONNABORTED:

2023

rpc_force_rebind(clnt);

2023

rpc_force_rebind(clnt);

2024

rpc_delay(task, 3*HZ);

2024

rpc_delay(task, 3*HZ);

2025

case -EPIPE:

2025

case -EPIPE:

2026

case -ENOTCONN:

2026

case -ENOTCONN:

2027

task->tk_action = call_bind;

2027

task->tk_action = call_bind;

2028

break;

2028

break;

2029

case -EAGAIN:

2029

case -EAGAIN:

2030

task->tk_action = call_transmit;

2030

task->tk_action = call_transmit;

2031

break;

2031

break;

2032

case -EIO:

2032

case -EIO:

2033

/* shutdown or soft timeout */

2033

/* shutdown or soft timeout */

2034

rpc_exit(task, status);

2034

rpc_exit(task, status);

2035

break;

2035

break;

2036

default:

2036

default:

2037

if (clnt->cl_chatty)

2037

if (clnt->cl_chatty)

2038

printk("%s: RPC call returned error %d\n",

2038

printk("%s: RPC call returned error %d\n",

2039

clnt->cl_program->name, -status);

2039

clnt->cl_program->name, -status);

2040

rpc_exit(task, status);

2040

rpc_exit(task, status);

2041

}

2041

}

2042

}

2042

}

2043

2044

/*

2044

/*

2045

* 6a. Handle RPC timeout

2045

* 6a. Handle RPC timeout

2046

* We do not release the request slot, so we keep using the

2046

* We do not release the request slot, so we keep using the

2047

* same XID for all retransmits.

2047

* same XID for all retransmits.

2048

*/

2048

*/

2049

static void

2049

static void

2050

call_timeout(struct rpc_task *task)

2050

call_timeout(struct rpc_task *task)

2051

{

2051

{

2052

struct rpc_clnt *clnt = task->tk_client;

2052

struct rpc_clnt *clnt = task->tk_client;

2053

2054

if (xprt_adjust_timeout(task->tk_rqstp) == 0) {

2054

if (xprt_adjust_timeout(task->tk_rqstp) == 0) {

2055

dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);

2055

dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);

2056

goto retry;

2056

goto retry;

2057

}

2057

}

2058

2059

dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);

2059

dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);

2060

task->tk_timeouts++;

2060

task->tk_timeouts++;

2061

2062

if (RPC_IS_SOFTCONN(task)) {

2062

if (RPC_IS_SOFTCONN(task)) {

2063

rpc_exit(task, -ETIMEDOUT);

2063

rpc_exit(task, -ETIMEDOUT);

2064

return;

2064

return;

2065

}

2065

}

2066

if (RPC_IS_SOFT(task)) {

2066

if (RPC_IS_SOFT(task)) {

2067

if (clnt->cl_chatty) {

2067

if (clnt->cl_chatty) {

2068

rcu_read_lock();

2068

rcu_read_lock();

2069

printk(KERN_NOTICE "%s: server %s not responding, timed out\n",

2069

printk(KERN_NOTICE "%s: server %s not responding, timed out\n",

2070

clnt->cl_program->name,

2070

clnt->cl_program->name,

2071

rcu_dereference(clnt->cl_xprt)->servername);

2071

rcu_dereference(clnt->cl_xprt)->servername);

2072

rcu_read_unlock();

2072

rcu_read_unlock();

2073

}

2073

}

2074

if (task->tk_flags & RPC_TASK_TIMEOUT)

2074

if (task->tk_flags & RPC_TASK_TIMEOUT)

2075

rpc_exit(task, -ETIMEDOUT);

2075

rpc_exit(task, -ETIMEDOUT);

2076

else

2076

else

2077

rpc_exit(task, -EIO);

2077

rpc_exit(task, -EIO);

2078

return;

2078

return;

2079

}

2079

}

2080

2081

if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {

2081

if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {

2082

task->tk_flags |= RPC_CALL_MAJORSEEN;

2082

task->tk_flags |= RPC_CALL_MAJORSEEN;

2083

if (clnt->cl_chatty) {

2083

if (clnt->cl_chatty) {

2084

rcu_read_lock();

2084

rcu_read_lock();

2085

printk(KERN_NOTICE "%s: server %s not responding, still trying\n",

2085

printk(KERN_NOTICE "%s: server %s not responding, still trying\n",

2086

clnt->cl_program->name,

2086

clnt->cl_program->name,

2087

rcu_dereference(clnt->cl_xprt)->servername);

2087

rcu_dereference(clnt->cl_xprt)->servername);

2088

rcu_read_unlock();

2088

rcu_read_unlock();

2089

}

2089

}

2090

}

2090

}

2091

rpc_force_rebind(clnt);

2091

rpc_force_rebind(clnt);

2092

/*

2092

/*

2093

* Did our request time out due to an RPCSEC_GSS out-of-sequence

2093

* Did our request time out due to an RPCSEC_GSS out-of-sequence

2094

* event? RFC2203 requires the server to drop all such requests.

2094

* event? RFC2203 requires the server to drop all such requests.

2095

*/

2095

*/

2096

rpcauth_invalcred(task);

2096

rpcauth_invalcred(task);

2097

2098

retry:

2098

retry:

2099

task->tk_action = call_bind;

2099

task->tk_action = call_bind;

2100

task->tk_status = 0;

2100

task->tk_status = 0;

2101

}

2101

}

2102

2103

/*

2103

/*

2104

* 7. Decode the RPC reply

2104

* 7. Decode the RPC reply

2105

*/

2105

*/

2106

static void

2106

static void

2107

call_decode(struct rpc_task *task)

2107

call_decode(struct rpc_task *task)

2108

{

2108

{

2109

struct rpc_clnt *clnt = task->tk_client;

2109

struct rpc_clnt *clnt = task->tk_client;

2110

struct rpc_rqst *req = task->tk_rqstp;

2110

struct rpc_rqst *req = task->tk_rqstp;

2111

kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;

2111

kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;

2112

__be32 *p;

2112

__be32 *p;

2113

2114

dprint_status(task);

2114

dprint_status(task);

2115

2116

if (task->tk_flags & RPC_CALL_MAJORSEEN) {

2116

if (task->tk_flags & RPC_CALL_MAJORSEEN) {

2117

if (clnt->cl_chatty) {

2117

if (clnt->cl_chatty) {

2118

rcu_read_lock();

2118

rcu_read_lock();

2119

printk(KERN_NOTICE "%s: server %s OK\n",

2119

printk(KERN_NOTICE "%s: server %s OK\n",

2120

clnt->cl_program->name,

2120

clnt->cl_program->name,

2121

rcu_dereference(clnt->cl_xprt)->servername);

2121

rcu_dereference(clnt->cl_xprt)->servername);

2122

rcu_read_unlock();

2122

rcu_read_unlock();

2123

}

2123

}

2124

task->tk_flags &= ~RPC_CALL_MAJORSEEN;

2124

task->tk_flags &= ~RPC_CALL_MAJORSEEN;

2125

}

2125

}

2126

2127

/*

2127

/*

2128

* Ensure that we see all writes made by xprt_complete_rqst()

2128

* Ensure that we see all writes made by xprt_complete_rqst()

2129

* before it changed req->rq_reply_bytes_recvd.

2129

* before it changed req->rq_reply_bytes_recvd.

2130

*/

2130

*/

2131

smp_rmb();

2131

smp_rmb();

2132

req->rq_rcv_buf.len = req->rq_private_buf.len;

2132

req->rq_rcv_buf.len = req->rq_private_buf.len;

2133

2134

/* Check that the softirq receive buffer is valid */

2134

/* Check that the softirq receive buffer is valid */

2135

WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,

2135

WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,

2136

sizeof(req->rq_rcv_buf)) != 0);

2136

sizeof(req->rq_rcv_buf)) != 0);

2137

2138

if (req->rq_rcv_buf.len < 12) {

2138

if (req->rq_rcv_buf.len < 12) {

2139

if (!RPC_IS_SOFT(task)) {

2139

if (!RPC_IS_SOFT(task)) {

2140

task->tk_action = call_bind;

2140

task->tk_action = call_bind;

2141

goto out_retry;

2141

goto out_retry;

2142

}

2142

}

2143

dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",

2143

dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",

2144

clnt->cl_program->name, task->tk_status);

2144

clnt->cl_program->name, task->tk_status);

2145

task->tk_action = call_timeout;

2145

task->tk_action = call_timeout;

2146

goto out_retry;

2146

goto out_retry;

2147

}

2147

}

2148

2149

p = rpc_verify_header(task);

2149

p = rpc_verify_header(task);

2150

if (IS_ERR(p)) {

2150

if (IS_ERR(p)) {

2151

if (p == ERR_PTR(-EAGAIN))

2151

if (p == ERR_PTR(-EAGAIN))

2152

goto out_retry;

2152

goto out_retry;

2153

return;

2153

return;

2154

}

2154

}

2155

2156

task->tk_action = rpc_exit_task;

2156

task->tk_action = rpc_exit_task;

2157

2158

if (decode) {

2158

if (decode) {

2159

task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,

2159

task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,

2160

task->tk_msg.rpc_resp);

2160

task->tk_msg.rpc_resp);

2161

}

2161

}

2162

dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,

2162

dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,

2163

task->tk_status);

2163

task->tk_status);

2164

return;

2164

return;

2165

out_retry:

2165

out_retry:

2166

task->tk_status = 0;

2166

task->tk_status = 0;

2167

/* Note: rpc_verify_header() may have freed the RPC slot */

2167

/* Note: rpc_verify_header() may have freed the RPC slot */

2168

if (task->tk_rqstp == req) {

2168

if (task->tk_rqstp == req) {

2169

req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;

2169

req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;

2170

if (task->tk_client->cl_discrtry)

2170

if (task->tk_client->cl_discrtry)

2171

xprt_conditional_disconnect(req->rq_xprt,

2171

xprt_conditional_disconnect(req->rq_xprt,

2172

req->rq_connect_cookie);

2172

req->rq_connect_cookie);

2173

}

2173

}

2174

}

2174

}

2175

2176

static __be32 *

2176

static __be32 *

2177

rpc_encode_header(struct rpc_task *task)

2177

rpc_encode_header(struct rpc_task *task)

2178

{

2178

{

2179

struct rpc_clnt *clnt = task->tk_client;

2179

struct rpc_clnt *clnt = task->tk_client;

2180

struct rpc_rqst *req = task->tk_rqstp;

2180

struct rpc_rqst *req = task->tk_rqstp;

2181

__be32 *p = req->rq_svec[0].iov_base;

2181

__be32 *p = req->rq_svec[0].iov_base;

2182

2183

/* FIXME: check buffer size? */

2183

/* FIXME: check buffer size? */

2184

2185

p = xprt_skip_transport_header(req->rq_xprt, p);

2185

p = xprt_skip_transport_header(req->rq_xprt, p);

2186

*p++ = req->rq_xid; /* XID */

2186

*p++ = req->rq_xid; /* XID */

2187

*p++ = htonl(RPC_CALL); /* CALL */

2187

*p++ = htonl(RPC_CALL); /* CALL */

2188

*p++ = htonl(RPC_VERSION); /* RPC version */

2188

*p++ = htonl(RPC_VERSION); /* RPC version */

2189

*p++ = htonl(clnt->cl_prog); /* program number */

2189

*p++ = htonl(clnt->cl_prog); /* program number */

2190

*p++ = htonl(clnt->cl_vers); /* program version */

2190

*p++ = htonl(clnt->cl_vers); /* program version */

2191

*p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */

2191

*p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */

2192

p = rpcauth_marshcred(task, p);

2192

p = rpcauth_marshcred(task, p);

2193

req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);

2193

req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);

2194

return p;

2194

return p;

2195

}

2195

}

2196

2197

static __be32 *

2197

static __be32 *

2198

rpc_verify_header(struct rpc_task *task)

2198

rpc_verify_header(struct rpc_task *task)

2199

{

2199

{

2200

struct rpc_clnt *clnt = task->tk_client;

2200

struct rpc_clnt *clnt = task->tk_client;

2201

struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];

2201

struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];

2202

int len = task->tk_rqstp->rq_rcv_buf.len >> 2;

2202

int len = task->tk_rqstp->rq_rcv_buf.len >> 2;

2203

__be32 *p = iov->iov_base;

2203

__be32 *p = iov->iov_base;

2204

u32 n;

2204

u32 n;

2205

int error = -EACCES;

2205

int error = -EACCES;

2206

2207

if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {

2207

if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {

2208

/* RFC-1014 says that the representation of XDR data must be a

2208

/* RFC-1014 says that the representation of XDR data must be a

2209

* multiple of four bytes

2209

* multiple of four bytes

2210

* - if it isn't pointer subtraction in the NFS client may give

2210

* - if it isn't pointer subtraction in the NFS client may give

2211

* undefined results

2211

* undefined results

2212

*/

2212

*/

2213

dprintk("RPC: %5u %s: XDR representation not a multiple of"

2213

dprintk("RPC: %5u %s: XDR representation not a multiple of"

2214

" 4 bytes: 0x%x\n", task->tk_pid, __func__,

2214

" 4 bytes: 0x%x\n", task->tk_pid, __func__,

2215

task->tk_rqstp->rq_rcv_buf.len);

2215

task->tk_rqstp->rq_rcv_buf.len);

2216

error = -EIO;

2216

error = -EIO;

2217

goto out_err;

2217

goto out_err;

2218

}

2218

}

2219

if ((len -= 3) < 0)

2219

if ((len -= 3) < 0)

2220

goto out_overflow;

2220

goto out_overflow;

2221

2222

p += 1; /* skip XID */

2222

p += 1; /* skip XID */

2223

if ((n = ntohl(*p++)) != RPC_REPLY) {

2223

if ((n = ntohl(*p++)) != RPC_REPLY) {

2224

dprintk("RPC: %5u %s: not an RPC reply: %x\n",

2224

dprintk("RPC: %5u %s: not an RPC reply: %x\n",

2225

task->tk_pid, __func__, n);

2225

task->tk_pid, __func__, n);

2226

error = -EIO;

2226

error = -EIO;

2227

goto out_garbage;

2227

goto out_garbage;

2228

}

2228

}

2229

2230

if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {

2230

if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {

2231

if (--len < 0)

2231

if (--len < 0)

2232

goto out_overflow;

2232

goto out_overflow;

2233

switch ((n = ntohl(*p++))) {

2233

switch ((n = ntohl(*p++))) {

2234

case RPC_AUTH_ERROR:

2234

case RPC_AUTH_ERROR:

2235

break;

2235

break;

2236

case RPC_MISMATCH:

2236

case RPC_MISMATCH:

2237

dprintk("RPC: %5u %s: RPC call version mismatch!\n",

2237

dprintk("RPC: %5u %s: RPC call version mismatch!\n",

2238

task->tk_pid, __func__);

2238

task->tk_pid, __func__);

2239

error = -EPROTONOSUPPORT;

2239

error = -EPROTONOSUPPORT;

2240

goto out_err;

2240

goto out_err;

2241

default:

2241

default:

2242

dprintk("RPC: %5u %s: RPC call rejected, "

2242

dprintk("RPC: %5u %s: RPC call rejected, "

2243

"unknown error: %x\n",

2243

"unknown error: %x\n",

2244

task->tk_pid, __func__, n);

2244

task->tk_pid, __func__, n);

2245

error = -EIO;

2245

error = -EIO;

2246

goto out_err;

2246

goto out_err;

2247

}

2247

}

2248

if (--len < 0)

2248

if (--len < 0)

2249

goto out_overflow;

2249

goto out_overflow;

2250

switch ((n = ntohl(*p++))) {

2250

switch ((n = ntohl(*p++))) {

2251

case RPC_AUTH_REJECTEDCRED:

2251

case RPC_AUTH_REJECTEDCRED:

2252

case RPC_AUTH_REJECTEDVERF:

2252

case RPC_AUTH_REJECTEDVERF:

2253

case RPCSEC_GSS_CREDPROBLEM:

2253

case RPCSEC_GSS_CREDPROBLEM:

2254

case RPCSEC_GSS_CTXPROBLEM:

2254

case RPCSEC_GSS_CTXPROBLEM:

2255

if (!task->tk_cred_retry)

2255

if (!task->tk_cred_retry)

2256

break;

2256

break;

2257

task->tk_cred_retry--;

2257

task->tk_cred_retry--;

2258

dprintk("RPC: %5u %s: retry stale creds\n",

2258

dprintk("RPC: %5u %s: retry stale creds\n",

2259

task->tk_pid, __func__);

2259

task->tk_pid, __func__);

2260

rpcauth_invalcred(task);

2260

rpcauth_invalcred(task);

2261

/* Ensure we obtain a new XID! */

2261

/* Ensure we obtain a new XID! */

2262

xprt_release(task);

2262

xprt_release(task);

2263

task->tk_action = call_reserve;

2263

task->tk_action = call_reserve;

2264

goto out_retry;

2264

goto out_retry;

2265

case RPC_AUTH_BADCRED:

2265

case RPC_AUTH_BADCRED:

2266

case RPC_AUTH_BADVERF:

2266

case RPC_AUTH_BADVERF:

2267

/* possibly garbled cred/verf? */

2267

/* possibly garbled cred/verf? */

2268

if (!task->tk_garb_retry)

2268

if (!task->tk_garb_retry)

2269

break;

2269

break;

2270

task->tk_garb_retry--;

2270

task->tk_garb_retry--;

2271

dprintk("RPC: %5u %s: retry garbled creds\n",

2271

dprintk("RPC: %5u %s: retry garbled creds\n",

2272

task->tk_pid, __func__);

2272

task->tk_pid, __func__);

2273

task->tk_action = call_bind;

2273

task->tk_action = call_bind;

2274

goto out_retry;

2274

goto out_retry;

2275

case RPC_AUTH_TOOWEAK:

2275

case RPC_AUTH_TOOWEAK:

2276

rcu_read_lock();

2276

rcu_read_lock();

2277

printk(KERN_NOTICE "RPC: server %s requires stronger "

2277

printk(KERN_NOTICE "RPC: server %s requires stronger "

2278

"authentication.\n",

2278

"authentication.\n",

2279

rcu_dereference(clnt->cl_xprt)->servername);

2279

rcu_dereference(clnt->cl_xprt)->servername);

2280

rcu_read_unlock();

2280

rcu_read_unlock();

2281

break;

2281

break;

2282

default:

2282

default:

2283

dprintk("RPC: %5u %s: unknown auth error: %x\n",

2283

dprintk("RPC: %5u %s: unknown auth error: %x\n",

2284

task->tk_pid, __func__, n);

2284

task->tk_pid, __func__, n);

2285

error = -EIO;

2285

error = -EIO;

2286

}

2286

}

2287

dprintk("RPC: %5u %s: call rejected %d\n",

2287

dprintk("RPC: %5u %s: call rejected %d\n",

2288

task->tk_pid, __func__, n);

2288

task->tk_pid, __func__, n);

2289

goto out_err;

2289

goto out_err;

2290

}

2290

}

2291

p = rpcauth_checkverf(task, p);

2291

p = rpcauth_checkverf(task, p);

2292

if (IS_ERR(p)) {

2292

if (IS_ERR(p)) {

2293

error = PTR_ERR(p);

2293

error = PTR_ERR(p);

2294

dprintk("RPC: %5u %s: auth check failed with %d\n",

2294

dprintk("RPC: %5u %s: auth check failed with %d\n",

2295

task->tk_pid, __func__, error);

2295

task->tk_pid, __func__, error);

2296

goto out_garbage; /* bad verifier, retry */

2296

goto out_garbage; /* bad verifier, retry */

2297

}

2297

}

2298

len = p - (__be32 *)iov->iov_base - 1;

2298

len = p - (__be32 *)iov->iov_base - 1;

2299

if (len < 0)

2299

if (len < 0)

2300

goto out_overflow;

2300

goto out_overflow;

2301

switch ((n = ntohl(*p++))) {

2301

switch ((n = ntohl(*p++))) {

2302

case RPC_SUCCESS:

2302

case RPC_SUCCESS:

2303

return p;

2303

return p;

2304

case RPC_PROG_UNAVAIL:

2304

case RPC_PROG_UNAVAIL:

2305

dprintk_rcu("RPC: %5u %s: program %u is unsupported "

2305

dprintk_rcu("RPC: %5u %s: program %u is unsupported "

2306

"by server %s\n", task->tk_pid, __func__,

2306

"by server %s\n", task->tk_pid, __func__,

2307

(unsigned int)clnt->cl_prog,

2307

(unsigned int)clnt->cl_prog,

2308

rcu_dereference(clnt->cl_xprt)->servername);

2308

rcu_dereference(clnt->cl_xprt)->servername);

2309

error = -EPFNOSUPPORT;

2309

error = -EPFNOSUPPORT;

2310

goto out_err;

2310

goto out_err;

2311

case RPC_PROG_MISMATCH:

2311

case RPC_PROG_MISMATCH:

2312

dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "

2312

dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "

2313

"by server %s\n", task->tk_pid, __func__,

2313

"by server %s\n", task->tk_pid, __func__,

2314

(unsigned int)clnt->cl_prog,

2314

(unsigned int)clnt->cl_prog,

2315

(unsigned int)clnt->cl_vers,

2315

(unsigned int)clnt->cl_vers,

2316

rcu_dereference(clnt->cl_xprt)->servername);

2316

rcu_dereference(clnt->cl_xprt)->servername);

2317

error = -EPROTONOSUPPORT;

2317

error = -EPROTONOSUPPORT;

2318

goto out_err;

2318

goto out_err;

2319

case RPC_PROC_UNAVAIL:

2319

case RPC_PROC_UNAVAIL:

2320

dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "

2320

dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "

2321

"version %u on server %s\n",

2321

"version %u on server %s\n",

2322

task->tk_pid, __func__,

2322

task->tk_pid, __func__,

2323

rpc_proc_name(task),

2323

rpc_proc_name(task),

2324

clnt->cl_prog, clnt->cl_vers,

2324

clnt->cl_prog, clnt->cl_vers,

2325

rcu_dereference(clnt->cl_xprt)->servername);

2325

rcu_dereference(clnt->cl_xprt)->servername);

2326

error = -EOPNOTSUPP;

2326

error = -EOPNOTSUPP;

2327

goto out_err;

2327

goto out_err;

2328

case RPC_GARBAGE_ARGS:

2328

case RPC_GARBAGE_ARGS:

2329

dprintk("RPC: %5u %s: server saw garbage\n",

2329

dprintk("RPC: %5u %s: server saw garbage\n",

2330

task->tk_pid, __func__);

2330

task->tk_pid, __func__);

2331

break; /* retry */

2331

break; /* retry */

2332

default:

2332

default:

2333

dprintk("RPC: %5u %s: server accept status: %x\n",

2333

dprintk("RPC: %5u %s: server accept status: %x\n",

2334

task->tk_pid, __func__, n);

2334

task->tk_pid, __func__, n);

2335

/* Also retry */

2335

/* Also retry */

2336

}

2336

}

2337

2338

out_garbage:

2338

out_garbage:

2339

clnt->cl_stats->rpcgarbage++;

2339

clnt->cl_stats->rpcgarbage++;

2340

if (task->tk_garb_retry) {

2340

if (task->tk_garb_retry) {

2341

task->tk_garb_retry--;

2341

task->tk_garb_retry--;

2342

dprintk("RPC: %5u %s: retrying\n",

2342

dprintk("RPC: %5u %s: retrying\n",

2343

task->tk_pid, __func__);

2343

task->tk_pid, __func__);

2344

task->tk_action = call_bind;

2344

task->tk_action = call_bind;

2345

out_retry:

2345

out_retry:

2346

return ERR_PTR(-EAGAIN);

2346

return ERR_PTR(-EAGAIN);

2347

}

2347

}

2348

out_err:

2348

out_err:

2349

rpc_exit(task, error);

2349

rpc_exit(task, error);

2350

dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,

2350

dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,

2351

__func__, error);

2351

__func__, error);

2352

return ERR_PTR(error);

2352

return ERR_PTR(error);

2353

out_overflow:

2353

out_overflow:

2354

dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,

2354

dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,

2355

__func__);

2355

__func__);

2356

goto out_garbage;

2356

goto out_garbage;

2357

}

2357

}

2358

2359

static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)

2359

static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)

2360

{

2360

{

2361

}

2361

}

2362

2363

static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)

2363

static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)

2364

{

2364

{

2365

return 0;

2365

return 0;

2366

}

2366

}

2367

2368

static struct rpc_procinfo rpcproc_null = {

2368

static struct rpc_procinfo rpcproc_null = {

2369

.p_encode = rpcproc_encode_null,

2369

.p_encode = rpcproc_encode_null,

2370

.p_decode = rpcproc_decode_null,

2370

.p_decode = rpcproc_decode_null,

2371

};

2371

};

2372

2373

static int rpc_ping(struct rpc_clnt *clnt)

2373

static int rpc_ping(struct rpc_clnt *clnt)

2374

{

2374

{

2375

struct rpc_message msg = {

2375

struct rpc_message msg = {

2376

.rpc_proc = &rpcproc_null,

2376

.rpc_proc = &rpcproc_null,

2377

};

2377

};

2378

int err;

2378

int err;

2379

msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);

2379

msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);

2380

err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);

2380

err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);

2381

put_rpccred(msg.rpc_cred);

2381

put_rpccred(msg.rpc_cred);

2382

return err;

2382

return err;

2383

}

2383

}

2384

2385

struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)

2385

struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)

2386

{

2386

{

2387

struct rpc_message msg = {

2387

struct rpc_message msg = {

2388

.rpc_proc = &rpcproc_null,

2388

.rpc_proc = &rpcproc_null,

2389

.rpc_cred = cred,

2389

.rpc_cred = cred,

2390

};

2390

};

2391

struct rpc_task_setup task_setup_data = {

2391

struct rpc_task_setup task_setup_data = {

2392

.rpc_client = clnt,

2392

.rpc_client = clnt,

2393

.rpc_message = &msg,

2393

.rpc_message = &msg,

2394

.callback_ops = &rpc_default_ops,

2394

.callback_ops = &rpc_default_ops,

2395

.flags = flags,

2395

.flags = flags,

2396

};

2396

};

2397

return rpc_run_task(&task_setup_data);

2397

return rpc_run_task(&task_setup_data);

2398

}

2398

}

2399

EXPORT_SYMBOL_GPL(rpc_call_null);

2399

EXPORT_SYMBOL_GPL(rpc_call_null);

2400

2401

#ifdef RPC_DEBUG

2401

#ifdef RPC_DEBUG

2402

static void rpc_show_header(void)

2402

static void rpc_show_header(void)

2403

{

2403

{

2404

printk(KERN_INFO "-pid- flgs status -client- --rqstp- "

2404

printk(KERN_INFO "-pid- flgs status -client- --rqstp- "

2405

"-timeout ---ops--\n");

2405

"-timeout ---ops--\n");

2406

}

2406

}

2407

2408

static void rpc_show_task(const struct rpc_clnt *clnt,

2408

static void rpc_show_task(const struct rpc_clnt *clnt,

2409

const struct rpc_task *task)

2409

const struct rpc_task *task)

2410

{

2410

{

2411

const char *rpc_waitq = "none";

2411

const char *rpc_waitq = "none";

2412

2413

if (RPC_IS_QUEUED(task))

2413

if (RPC_IS_QUEUED(task))

2414

rpc_waitq = rpc_qname(task->tk_waitqueue);

2414

rpc_waitq = rpc_qname(task->tk_waitqueue);

2415

2416

printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",

2416

printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",

2417

task->tk_pid, task->tk_flags, task->tk_status,

2417

task->tk_pid, task->tk_flags, task->tk_status,

2418

clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,

2418

clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,

2419

clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),

2419

clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),

2420

task->tk_action, rpc_waitq);

2420

task->tk_action, rpc_waitq);

2421

}

2421

}

2422

2423

void rpc_show_tasks(struct net *net)

2423

void rpc_show_tasks(struct net *net)

2424

{

2424

{

2425

struct rpc_clnt *clnt;

2425

struct rpc_clnt *clnt;

2426

struct rpc_task *task;

2426

struct rpc_task *task;

2427

int header = 0;

2427

int header = 0;

2428

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

2428

struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

2429

2430

spin_lock(&sn->rpc_client_lock);

2430

spin_lock(&sn->rpc_client_lock);

2431

list_for_each_entry(clnt, &sn->all_clients, cl_clients) {

2431

list_for_each_entry(clnt, &sn->all_clients, cl_clients) {

2432

spin_lock(&clnt->cl_lock);

2432

spin_lock(&clnt->cl_lock);

2433

list_for_each_entry(task, &clnt->cl_tasks, tk_task) {

2433

list_for_each_entry(task, &clnt->cl_tasks, tk_task) {

2434

if (!header) {

2434

if (!header) {

2435

rpc_show_header();

2435

rpc_show_header();

2436

header++;

2436

header++;

2437

}

2437

}

2438

rpc_show_task(clnt, task);

2438

rpc_show_task(clnt, task);

2439

}

2439

}

2440

spin_unlock(&clnt->cl_lock);

2440

spin_unlock(&clnt->cl_lock);

2441

}

2441

}

2442

spin_unlock(&sn->rpc_client_lock);

2442

spin_unlock(&sn->rpc_client_lock);

2443

}

2443

}

GITLAB

SUNRPC: Ensure call_connect_status() deals correctly with SOFTCONN tasks

 /*
  *  linux/net/sunrpc/clnt.c
  *
  *  This file contains the high-level RPC interface.
  *  It is modeled as a finite state machine to support both synchronous
  *  and asynchronous requests.
  *
  *  -	RPC header generation and argument serialization.
  *  -	Credential refresh.
  *  -	TCP connect handling.
  *  -	Retry of operation when it is suspected the operation failed because
  *	of uid squashing on the server, or when the credentials were stale
  *	and need to be refreshed, or when a packet was damaged in transit.
  *	This may be have to be moved to the VFS layer.
  *
  *  Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
  *  Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kallsyms.h>
 #include <linux/mm.h>
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/slab.h>
 #include <linux/rcupdate.h>
 #include <linux/utsname.h>
 #include <linux/workqueue.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/un.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/addr.h>
 #include <linux/sunrpc/rpc_pipe_fs.h>
 #include <linux/sunrpc/metrics.h>
 #include <linux/sunrpc/bc_xprt.h>
 #include <trace/events/sunrpc.h>
 #include "sunrpc.h"
 #include "netns.h"
 #ifdef RPC_DEBUG
 # define RPCDBG_FACILITY	RPCDBG_CALL
 #endif
 #define dprint_status(t)					\
 	dprintk("RPC: %5u %s (status %d)\n", t->tk_pid,		\
 			__func__, t->tk_status)
 /*
  * All RPC clients are linked into this list
  */
 static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
 static void	call_start(struct rpc_task *task);
 static void	call_reserve(struct rpc_task *task);
 static void	call_reserveresult(struct rpc_task *task);
 static void	call_allocate(struct rpc_task *task);
 static void	call_decode(struct rpc_task *task);
 static void	call_bind(struct rpc_task *task);
 static void	call_bind_status(struct rpc_task *task);
 static void	call_transmit(struct rpc_task *task);
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
 static void	call_bc_transmit(struct rpc_task *task);
 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
 static void	call_status(struct rpc_task *task);
 static void	call_transmit_status(struct rpc_task *task);
 static void	call_refresh(struct rpc_task *task);
 static void	call_refreshresult(struct rpc_task *task);
 static void	call_timeout(struct rpc_task *task);
 static void	call_connect(struct rpc_task *task);
 static void	call_connect_status(struct rpc_task *task);
 static __be32	*rpc_encode_header(struct rpc_task *task);
 static __be32	*rpc_verify_header(struct rpc_task *task);
 static int	rpc_ping(struct rpc_clnt *clnt);
 static void rpc_register_client(struct rpc_clnt *clnt)
 {
 	struct net *net = rpc_net_ns(clnt);
 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 	spin_lock(&sn->rpc_client_lock);
 	list_add(&clnt->cl_clients, &sn->all_clients);
 	spin_unlock(&sn->rpc_client_lock);
 }
 static void rpc_unregister_client(struct rpc_clnt *clnt)
 {
 	struct net *net = rpc_net_ns(clnt);
 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 	spin_lock(&sn->rpc_client_lock);
 	list_del(&clnt->cl_clients);
 	spin_unlock(&sn->rpc_client_lock);
 }
 static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
 {
 	rpc_remove_client_dir(clnt);
 }
 static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
 {
 	struct net *net = rpc_net_ns(clnt);
 	struct super_block *pipefs_sb;
 	pipefs_sb = rpc_get_sb_net(net);
 	if (pipefs_sb) {
 		__rpc_clnt_remove_pipedir(clnt);
 		rpc_put_sb_net(net);
 	}
 }
 static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
 				    struct rpc_clnt *clnt)
 {
 	static uint32_t clntid;
 	const char *dir_name = clnt->cl_program->pipe_dir_name;
 	char name[15];
 	struct dentry *dir, *dentry;
 	dir = rpc_d_lookup_sb(sb, dir_name);
 	if (dir == NULL) {
 		pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
 		return dir;
 	}
 	for (;;) {
 		snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
 		name[sizeof(name) - 1] = '\0';
 		dentry = rpc_create_client_dir(dir, name, clnt);
 		if (!IS_ERR(dentry))
 			break;
 		if (dentry == ERR_PTR(-EEXIST))
 			continue;
 		printk(KERN_INFO "RPC: Couldn't create pipefs entry"
 				" %s/%s, error %ld\n",
 				dir_name, name, PTR_ERR(dentry));
 		break;
 	}
 	dput(dir);
 	return dentry;
 }
 static int
 rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
 {
 	struct dentry *dentry;
 	if (clnt->cl_program->pipe_dir_name != NULL) {
 		dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
 		if (IS_ERR(dentry))
 			return PTR_ERR(dentry);
 	}
 	return 0;
 }
 static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
 {
 	if (clnt->cl_program->pipe_dir_name == NULL)
 		return 1;
 	switch (event) {
 	case RPC_PIPEFS_MOUNT:
 		if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
 			return 1;
 		if (atomic_read(&clnt->cl_count) == 0)
 			return 1;
 		break;
 	case RPC_PIPEFS_UMOUNT:
 		if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
 			return 1;
 		break;
 	}
 	return 0;
 }
 static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
 				   struct super_block *sb)
 {
 	struct dentry *dentry;
 	int err = 0;
 	switch (event) {
 	case RPC_PIPEFS_MOUNT:
 		dentry = rpc_setup_pipedir_sb(sb, clnt);
 		if (!dentry)
 			return -ENOENT;
 		if (IS_ERR(dentry))
 			return PTR_ERR(dentry);
 		break;
 	case RPC_PIPEFS_UMOUNT:
 		__rpc_clnt_remove_pipedir(clnt);
 		break;
 	default:
 		printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);
 		return -ENOTSUPP;
 	}
 	return err;
 }
 static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,
 				struct super_block *sb)
 {
 	int error = 0;
 	for (;; clnt = clnt->cl_parent) {
 		if (!rpc_clnt_skip_event(clnt, event))
 			error = __rpc_clnt_handle_event(clnt, event, sb);
 		if (error || clnt == clnt->cl_parent)
 			break;
 	}
 	return error;
 }
 static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
 {
 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 	struct rpc_clnt *clnt;
 	spin_lock(&sn->rpc_client_lock);
 	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
 		if (rpc_clnt_skip_event(clnt, event))
 			continue;
 		spin_unlock(&sn->rpc_client_lock);
 		return clnt;
 	}
 	spin_unlock(&sn->rpc_client_lock);
 	return NULL;
 }
 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
 			    void *ptr)
 {
 	struct super_block *sb = ptr;
 	struct rpc_clnt *clnt;
 	int error = 0;
 	while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
 		error = __rpc_pipefs_event(clnt, event, sb);
 		if (error)
 			break;
 	}
 	return error;
 }
 static struct notifier_block rpc_clients_block = {
 	.notifier_call	= rpc_pipefs_event,
 	.priority	= SUNRPC_PIPEFS_RPC_PRIO,
 };
 int rpc_clients_notifier_register(void)
 {
 	return rpc_pipefs_notifier_register(&rpc_clients_block);
 }
 void rpc_clients_notifier_unregister(void)
 {
 	return rpc_pipefs_notifier_unregister(&rpc_clients_block);
 }
 static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
 		struct rpc_xprt *xprt,
 		const struct rpc_timeout *timeout)
 {
 	struct rpc_xprt *old;
 	spin_lock(&clnt->cl_lock);
 	old = rcu_dereference_protected(clnt->cl_xprt,
 			lockdep_is_held(&clnt->cl_lock));
 	if (!xprt_bound(xprt))
 		clnt->cl_autobind = 1;
 	clnt->cl_timeout = timeout;
 	rcu_assign_pointer(clnt->cl_xprt, xprt);
 	spin_unlock(&clnt->cl_lock);
 	return old;
 }
 static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
 {
 	clnt->cl_nodelen = strlen(nodename);
 	if (clnt->cl_nodelen > UNX_MAXNODENAME)
 		clnt->cl_nodelen = UNX_MAXNODENAME;
 	memcpy(clnt->cl_nodename, nodename, clnt->cl_nodelen);
 }
 static int rpc_client_register(struct rpc_clnt *clnt,
 			       rpc_authflavor_t pseudoflavor,
 			       const char *client_name)
 {
 	struct rpc_auth_create_args auth_args = {
 		.pseudoflavor = pseudoflavor,
 		.target_name = client_name,
 	};
 	struct rpc_auth *auth;
 	struct net *net = rpc_net_ns(clnt);
 	struct super_block *pipefs_sb;
 	int err;
 	pipefs_sb = rpc_get_sb_net(net);
 	if (pipefs_sb) {
 		err = rpc_setup_pipedir(pipefs_sb, clnt);
 		if (err)
 			goto out;
 	}
 	rpc_register_client(clnt);
 	if (pipefs_sb)
 		rpc_put_sb_net(net);
 	auth = rpcauth_create(&auth_args, clnt);
 	if (IS_ERR(auth)) {
 		dprintk("RPC:       Couldn't create auth handle (flavor %u)\n",
 				pseudoflavor);
 		err = PTR_ERR(auth);
 		goto err_auth;
 	}
 	return 0;
 err_auth:
 	pipefs_sb = rpc_get_sb_net(net);
 	rpc_unregister_client(clnt);
 	__rpc_clnt_remove_pipedir(clnt);
 out:
 	if (pipefs_sb)
 		rpc_put_sb_net(net);
 	return err;
 }
 static DEFINE_IDA(rpc_clids);
 static int rpc_alloc_clid(struct rpc_clnt *clnt)
 {
 	int clid;
 	clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);
 	if (clid < 0)
 		return clid;
 	clnt->cl_clid = clid;
 	return 0;
 }
 static void rpc_free_clid(struct rpc_clnt *clnt)
 {
 	ida_simple_remove(&rpc_clids, clnt->cl_clid);
 }
 static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
 		struct rpc_xprt *xprt,
 		struct rpc_clnt *parent)
 {
 	const struct rpc_program *program = args->program;
 	const struct rpc_version *version;
 	struct rpc_clnt *clnt = NULL;
 	const struct rpc_timeout *timeout;
 	int err;
 	/* sanity check the name before trying to print it */
 	dprintk("RPC:       creating %s client for %s (xprt %p)\n",
 			program->name, args->servername, xprt);
 	err = rpciod_up();
 	if (err)
 		goto out_no_rpciod;
 	err = -EINVAL;
 	if (args->version >= program->nrvers)
 		goto out_err;
 	version = program->version[args->version];
 	if (version == NULL)
 		goto out_err;
 	err = -ENOMEM;
 	clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
 	if (!clnt)
 		goto out_err;
 	clnt->cl_parent = parent ? : clnt;
 	err = rpc_alloc_clid(clnt);
 	if (err)
 		goto out_no_clid;
 	clnt->cl_procinfo = version->procs;
 	clnt->cl_maxproc  = version->nrprocs;
 	clnt->cl_prog     = args->prognumber ? : program->number;
 	clnt->cl_vers     = version->number;
 	clnt->cl_stats    = program->stats;
 	clnt->cl_metrics  = rpc_alloc_iostats(clnt);
 	rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
 	err = -ENOMEM;
 	if (clnt->cl_metrics == NULL)
 		goto out_no_stats;
 	clnt->cl_program  = program;
 	INIT_LIST_HEAD(&clnt->cl_tasks);
 	spin_lock_init(&clnt->cl_lock);
 	timeout = xprt->timeout;
 	if (args->timeout != NULL) {
 		memcpy(&clnt->cl_timeout_default, args->timeout,
 				sizeof(clnt->cl_timeout_default));
 		timeout = &clnt->cl_timeout_default;
 	}
 	rpc_clnt_set_transport(clnt, xprt, timeout);
 	clnt->cl_rtt = &clnt->cl_rtt_default;
 	rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
 	atomic_set(&clnt->cl_count, 1);
 	/* save the nodename */
 	rpc_clnt_set_nodename(clnt, utsname()->nodename);
 	err = rpc_client_register(clnt, args->authflavor, args->client_name);
 	if (err)
 		goto out_no_path;
 	if (parent)
 		atomic_inc(&parent->cl_count);
 	return clnt;
 out_no_path:
 	rpc_free_iostats(clnt->cl_metrics);
 out_no_stats:
 	rpc_free_clid(clnt);
 out_no_clid:
 	kfree(clnt);
 out_err:
 	rpciod_down();
 out_no_rpciod:
 	xprt_put(xprt);
 	return ERR_PTR(err);
 }
 /**
  * rpc_create - create an RPC client and transport with one call
  * @args: rpc_clnt create argument structure
  *
  * Creates and initializes an RPC transport and an RPC client.
  *
  * It can ping the server in order to determine if it is up, and to see if
  * it supports this program and version.  RPC_CLNT_CREATE_NOPING disables
  * this behavior so asynchronous tasks can also use rpc_create.
  */
 struct rpc_clnt *rpc_create(struct rpc_create_args *args)
 {
 	struct rpc_xprt *xprt;
 	struct rpc_clnt *clnt;
 	struct xprt_create xprtargs = {
 		.net = args->net,
 		.ident = args->protocol,
 		.srcaddr = args->saddress,
 		.dstaddr = args->address,
 		.addrlen = args->addrsize,
 		.servername = args->servername,
 		.bc_xprt = args->bc_xprt,
 	};
 	char servername[48];
 	if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
 		xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
 	if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
 		xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
 	/*
 	 * If the caller chooses not to specify a hostname, whip
 	 * up a string representation of the passed-in address.
 	 */
 	if (xprtargs.servername == NULL) {
 		struct sockaddr_un *sun =
 				(struct sockaddr_un *)args->address;
 		struct sockaddr_in *sin =
 				(struct sockaddr_in *)args->address;
 		struct sockaddr_in6 *sin6 =
 				(struct sockaddr_in6 *)args->address;
 		servername[0] = '\0';
 		switch (args->address->sa_family) {
 		case AF_LOCAL:
 			snprintf(servername, sizeof(servername), "%s",
 				 sun->sun_path);
 			break;
 		case AF_INET:
 			snprintf(servername, sizeof(servername), "%pI4",
 				 &sin->sin_addr.s_addr);
 			break;
 		case AF_INET6:
 			snprintf(servername, sizeof(servername), "%pI6",
 				 &sin6->sin6_addr);
 			break;
 		default:
 			/* caller wants default server name, but
 			 * address family isn't recognized. */
 			return ERR_PTR(-EINVAL);
 		}
 		xprtargs.servername = servername;
 	}
 	xprt = xprt_create_transport(&xprtargs);
 	if (IS_ERR(xprt))
 		return (struct rpc_clnt *)xprt;
 	/*
 	 * By default, kernel RPC client connects from a reserved port.
 	 * CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
 	 * but it is always enabled for rpciod, which handles the connect
 	 * operation.
 	 */
 	xprt->resvport = 1;
 	if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
 		xprt->resvport = 0;
 	clnt = rpc_new_client(args, xprt, NULL);
 	if (IS_ERR(clnt))
 		return clnt;
 	if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
 		int err = rpc_ping(clnt);
 		if (err != 0) {
 			rpc_shutdown_client(clnt);
 			return ERR_PTR(err);
 		}
 	}
 	clnt->cl_softrtry = 1;
 	if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
 		clnt->cl_softrtry = 0;
 	if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
 		clnt->cl_autobind = 1;
 	if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
 		clnt->cl_discrtry = 1;
 	if (!(args->flags & RPC_CLNT_CREATE_QUIET))
 		clnt->cl_chatty = 1;
 	return clnt;
 }
 EXPORT_SYMBOL_GPL(rpc_create);
 /*
  * This function clones the RPC client structure. It allows us to share the
  * same transport while varying parameters such as the authentication
  * flavour.
  */
 static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
 					   struct rpc_clnt *clnt)
 {
 	struct rpc_xprt *xprt;
 	struct rpc_clnt *new;
 	int err;
 	err = -ENOMEM;
 	rcu_read_lock();
 	xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
 	rcu_read_unlock();
 	if (xprt == NULL)
 		goto out_err;
 	args->servername = xprt->servername;
 	new = rpc_new_client(args, xprt, clnt);
 	if (IS_ERR(new)) {
 		err = PTR_ERR(new);
 		goto out_err;
 	}
 	/* Turn off autobind on clones */
 	new->cl_autobind = 0;
 	new->cl_softrtry = clnt->cl_softrtry;
 	new->cl_discrtry = clnt->cl_discrtry;
 	new->cl_chatty = clnt->cl_chatty;
 	return new;
 out_err:
 	dprintk("RPC:       %s: returned error %d\n", __func__, err);
 	return ERR_PTR(err);
 }
 /**
  * rpc_clone_client - Clone an RPC client structure
  *
  * @clnt: RPC client whose parameters are copied
  *
  * Returns a fresh RPC client or an ERR_PTR.
  */
 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
 {
 	struct rpc_create_args args = {
 		.program	= clnt->cl_program,
 		.prognumber	= clnt->cl_prog,
 		.version	= clnt->cl_vers,
 		.authflavor	= clnt->cl_auth->au_flavor,
 	};
 	return __rpc_clone_client(&args, clnt);
 }
 EXPORT_SYMBOL_GPL(rpc_clone_client);
 /**
  * rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
  *
  * @clnt: RPC client whose parameters are copied
  * @flavor: security flavor for new client
  *
  * Returns a fresh RPC client or an ERR_PTR.
  */
 struct rpc_clnt *
 rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
 {
 	struct rpc_create_args args = {
 		.program	= clnt->cl_program,
 		.prognumber	= clnt->cl_prog,
 		.version	= clnt->cl_vers,
 		.authflavor	= flavor,
 	};
 	return __rpc_clone_client(&args, clnt);
 }
 EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
 /**
  * rpc_switch_client_transport: switch the RPC transport on the fly
  * @clnt: pointer to a struct rpc_clnt
  * @args: pointer to the new transport arguments
  * @timeout: pointer to the new timeout parameters
  *
  * This function allows the caller to switch the RPC transport for the
  * rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
  * server, for instance.  It assumes that the caller has ensured that
  * there are no active RPC tasks by using some form of locking.
  *
  * Returns zero if "clnt" is now using the new xprt.  Otherwise a
  * negative errno is returned, and "clnt" continues to use the old
  * xprt.
  */
 int rpc_switch_client_transport(struct rpc_clnt *clnt,
 		struct xprt_create *args,
 		const struct rpc_timeout *timeout)
 {
 	const struct rpc_timeout *old_timeo;
 	rpc_authflavor_t pseudoflavor;
 	struct rpc_xprt *xprt, *old;
 	struct rpc_clnt *parent;
 	int err;
 	xprt = xprt_create_transport(args);
 	if (IS_ERR(xprt)) {
 		dprintk("RPC:       failed to create new xprt for clnt %p\n",
 			clnt);
 		return PTR_ERR(xprt);
 	}
 	pseudoflavor = clnt->cl_auth->au_flavor;
 	old_timeo = clnt->cl_timeout;
 	old = rpc_clnt_set_transport(clnt, xprt, timeout);
 	rpc_unregister_client(clnt);
 	__rpc_clnt_remove_pipedir(clnt);
 	/*
 	 * A new transport was created.  "clnt" therefore
 	 * becomes the root of a new cl_parent tree.  clnt's
 	 * children, if it has any, still point to the old xprt.
 	 */
 	parent = clnt->cl_parent;
 	clnt->cl_parent = clnt;
 	/*
 	 * The old rpc_auth cache cannot be re-used.  GSS
 	 * contexts in particular are between a single
 	 * client and server.
 	 */
 	err = rpc_client_register(clnt, pseudoflavor, NULL);
 	if (err)
 		goto out_revert;
 	synchronize_rcu();
 	if (parent != clnt)
 		rpc_release_client(parent);
 	xprt_put(old);
 	dprintk("RPC:       replaced xprt for clnt %p\n", clnt);
 	return 0;
 out_revert:
 	rpc_clnt_set_transport(clnt, old, old_timeo);
 	clnt->cl_parent = parent;
 	rpc_client_register(clnt, pseudoflavor, NULL);
 	xprt_put(xprt);
 	dprintk("RPC:       failed to switch xprt for clnt %p\n", clnt);
 	return err;
 }
 EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
 /*
  * Kill all tasks for the given client.
  * XXX: kill their descendants as well?
  */
 void rpc_killall_tasks(struct rpc_clnt *clnt)
 {
 	struct rpc_task	*rovr;
 	if (list_empty(&clnt->cl_tasks))
 		return;
 	dprintk("RPC:       killing all tasks for client %p\n", clnt);
 	/*
 	 * Spin lock all_tasks to prevent changes...
 	 */
 	spin_lock(&clnt->cl_lock);
 	list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
 		if (!RPC_IS_ACTIVATED(rovr))
 			continue;
 		if (!(rovr->tk_flags & RPC_TASK_KILLED)) {
 			rovr->tk_flags |= RPC_TASK_KILLED;
 			rpc_exit(rovr, -EIO);
 			if (RPC_IS_QUEUED(rovr))
 				rpc_wake_up_queued_task(rovr->tk_waitqueue,
 							rovr);
 		}
 	}
 	spin_unlock(&clnt->cl_lock);
 }
 EXPORT_SYMBOL_GPL(rpc_killall_tasks);
 /*
  * Properly shut down an RPC client, terminating all outstanding
  * requests.
  */
 void rpc_shutdown_client(struct rpc_clnt *clnt)
 {
 	might_sleep();
 	dprintk_rcu("RPC:       shutting down %s client for %s\n",
 			clnt->cl_program->name,
 			rcu_dereference(clnt->cl_xprt)->servername);
 	while (!list_empty(&clnt->cl_tasks)) {
 		rpc_killall_tasks(clnt);
 		wait_event_timeout(destroy_wait,
 			list_empty(&clnt->cl_tasks), 1*HZ);
 	}
 	rpc_release_client(clnt);
 }
 EXPORT_SYMBOL_GPL(rpc_shutdown_client);
 /*
  * Free an RPC client
  */
 static struct rpc_clnt *
 rpc_free_client(struct rpc_clnt *clnt)
 {
 	struct rpc_clnt *parent = NULL;
 	dprintk_rcu("RPC:       destroying %s client for %s\n",
 			clnt->cl_program->name,
 			rcu_dereference(clnt->cl_xprt)->servername);
 	if (clnt->cl_parent != clnt)
 		parent = clnt->cl_parent;
 	rpc_clnt_remove_pipedir(clnt);
 	rpc_unregister_client(clnt);
 	rpc_free_iostats(clnt->cl_metrics);
 	clnt->cl_metrics = NULL;
 	xprt_put(rcu_dereference_raw(clnt->cl_xprt));
 	rpciod_down();
 	rpc_free_clid(clnt);
 	kfree(clnt);
 	return parent;
 }
 /*
  * Free an RPC client
  */
 static struct rpc_clnt *
 rpc_free_auth(struct rpc_clnt *clnt)
 {
 	if (clnt->cl_auth == NULL)
 		return rpc_free_client(clnt);
 	/*
 	 * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
 	 *       release remaining GSS contexts. This mechanism ensures
 	 *       that it can do so safely.
 	 */
 	atomic_inc(&clnt->cl_count);
 	rpcauth_release(clnt->cl_auth);
 	clnt->cl_auth = NULL;
 	if (atomic_dec_and_test(&clnt->cl_count))
 		return rpc_free_client(clnt);
 	return NULL;
 }
 /*
  * Release reference to the RPC client
  */
 void
 rpc_release_client(struct rpc_clnt *clnt)
 {
 	dprintk("RPC:       rpc_release_client(%p)\n", clnt);
 	do {
 		if (list_empty(&clnt->cl_tasks))
 			wake_up(&destroy_wait);
 		if (!atomic_dec_and_test(&clnt->cl_count))
 			break;
 		clnt = rpc_free_auth(clnt);
 	} while (clnt != NULL);
 }
 EXPORT_SYMBOL_GPL(rpc_release_client);
 /**
  * rpc_bind_new_program - bind a new RPC program to an existing client
  * @old: old rpc_client
  * @program: rpc program to set
  * @vers: rpc program version
  *
  * Clones the rpc client and sets up a new RPC program. This is mainly
  * of use for enabling different RPC programs to share the same transport.
  * The Sun NFSv2/v3 ACL protocol can do this.
  */
 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
 				      const struct rpc_program *program,
 				      u32 vers)
 {
 	struct rpc_create_args args = {
 		.program	= program,
 		.prognumber	= program->number,
 		.version	= vers,
 		.authflavor	= old->cl_auth->au_flavor,
 	};
 	struct rpc_clnt *clnt;
 	int err;
 	clnt = __rpc_clone_client(&args, old);
 	if (IS_ERR(clnt))
 		goto out;
 	err = rpc_ping(clnt);
 	if (err != 0) {
 		rpc_shutdown_client(clnt);
 		clnt = ERR_PTR(err);
 	}
 out:
 	return clnt;
 }
 EXPORT_SYMBOL_GPL(rpc_bind_new_program);
 void rpc_task_release_client(struct rpc_task *task)
 {
 	struct rpc_clnt *clnt = task->tk_client;
 	if (clnt != NULL) {
 		/* Remove from client task list */
 		spin_lock(&clnt->cl_lock);
 		list_del(&task->tk_task);
 		spin_unlock(&clnt->cl_lock);
 		task->tk_client = NULL;
 		rpc_release_client(clnt);
 	}
 }
 static
 void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
 {
 	if (clnt != NULL) {
 		rpc_task_release_client(task);
 		task->tk_client = clnt;
 		atomic_inc(&clnt->cl_count);
 		if (clnt->cl_softrtry)
 			task->tk_flags |= RPC_TASK_SOFT;
 		if (clnt->cl_noretranstimeo)
 			task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
 		if (sk_memalloc_socks()) {
 			struct rpc_xprt *xprt;
 			rcu_read_lock();
 			xprt = rcu_dereference(clnt->cl_xprt);
 			if (xprt->swapper)
 				task->tk_flags |= RPC_TASK_SWAPPER;
 			rcu_read_unlock();
 		}
 		/* Add to the client's list of all tasks */
 		spin_lock(&clnt->cl_lock);
 		list_add_tail(&task->tk_task, &clnt->cl_tasks);
 		spin_unlock(&clnt->cl_lock);
 	}
 }
 void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt)
 {
 	rpc_task_release_client(task);
 	rpc_task_set_client(task, clnt);
 }
 EXPORT_SYMBOL_GPL(rpc_task_reset_client);
 static void
 rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
 {
 	if (msg != NULL) {
 		task->tk_msg.rpc_proc = msg->rpc_proc;
 		task->tk_msg.rpc_argp = msg->rpc_argp;
 		task->tk_msg.rpc_resp = msg->rpc_resp;
 		if (msg->rpc_cred != NULL)
 			task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);
 	}
 }
 /*
  * Default callback for async RPC calls
  */
 static void
 rpc_default_callback(struct rpc_task *task, void *data)
 {
 }
 static const struct rpc_call_ops rpc_default_ops = {
 	.rpc_call_done = rpc_default_callback,
 };
 /**
  * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
  * @task_setup_data: pointer to task initialisation data
  */
 struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
 {
 	struct rpc_task *task;
 	task = rpc_new_task(task_setup_data);
 	if (IS_ERR(task))
 		goto out;
 	rpc_task_set_client(task, task_setup_data->rpc_client);
 	rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
 	if (task->tk_action == NULL)
 		rpc_call_start(task);
 	atomic_inc(&task->tk_count);
 	rpc_execute(task);
 out:
 	return task;
 }
 EXPORT_SYMBOL_GPL(rpc_run_task);
 /**
  * rpc_call_sync - Perform a synchronous RPC call
  * @clnt: pointer to RPC client
  * @msg: RPC call parameters
  * @flags: RPC call flags
  */
 int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
 {
 	struct rpc_task	*task;
 	struct rpc_task_setup task_setup_data = {
 		.rpc_client = clnt,
 		.rpc_message = msg,
 		.callback_ops = &rpc_default_ops,
 		.flags = flags,
 	};
 	int status;
 	WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
 	if (flags & RPC_TASK_ASYNC) {
 		rpc_release_calldata(task_setup_data.callback_ops,
 			task_setup_data.callback_data);
 		return -EINVAL;
 	}
 	task = rpc_run_task(&task_setup_data);
 	if (IS_ERR(task))
 		return PTR_ERR(task);
 	status = task->tk_status;
 	rpc_put_task(task);
 	return status;
 }
 EXPORT_SYMBOL_GPL(rpc_call_sync);
 /**
  * rpc_call_async - Perform an asynchronous RPC call
  * @clnt: pointer to RPC client
  * @msg: RPC call parameters
  * @flags: RPC call flags
  * @tk_ops: RPC call ops
  * @data: user call data
  */
 int
 rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
 	       const struct rpc_call_ops *tk_ops, void *data)
 {
 	struct rpc_task	*task;
 	struct rpc_task_setup task_setup_data = {
 		.rpc_client = clnt,
 		.rpc_message = msg,
 		.callback_ops = tk_ops,
 		.callback_data = data,
 		.flags = flags|RPC_TASK_ASYNC,
 	};
 	task = rpc_run_task(&task_setup_data);
 	if (IS_ERR(task))
 		return PTR_ERR(task);
 	rpc_put_task(task);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(rpc_call_async);
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /**
  * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
  * rpc_execute against it
  * @req: RPC request
  * @tk_ops: RPC call ops
  */
 struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
 				const struct rpc_call_ops *tk_ops)
 {
 	struct rpc_task *task;
 	struct xdr_buf *xbufp = &req->rq_snd_buf;
 	struct rpc_task_setup task_setup_data = {
 		.callback_ops = tk_ops,
 	};
 	dprintk("RPC: rpc_run_bc_task req= %p\n", req);
 	/*
 	 * Create an rpc_task to send the data
 	 */
 	task = rpc_new_task(&task_setup_data);
 	if (IS_ERR(task)) {
 		xprt_free_bc_request(req);
 		goto out;
 	}
 	task->tk_rqstp = req;
 	/*
 	 * Set up the xdr_buf length.
 	 * This also indicates that the buffer is XDR encoded already.
 	 */
 	xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
 			xbufp->tail[0].iov_len;
 	task->tk_action = call_bc_transmit;
 	atomic_inc(&task->tk_count);
 	WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
 	rpc_execute(task);
 out:
 	dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
 	return task;
 }
 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
 void
 rpc_call_start(struct rpc_task *task)
 {
 	task->tk_action = call_start;
 }
 EXPORT_SYMBOL_GPL(rpc_call_start);
 /**
  * rpc_peeraddr - extract remote peer address from clnt's xprt
  * @clnt: RPC client structure
  * @buf: target buffer
  * @bufsize: length of target buffer
  *
  * Returns the number of bytes that are actually in the stored address.
  */
 size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
 {
 	size_t bytes;
 	struct rpc_xprt *xprt;
 	rcu_read_lock();
 	xprt = rcu_dereference(clnt->cl_xprt);
 	bytes = xprt->addrlen;
 	if (bytes > bufsize)
 		bytes = bufsize;
 	memcpy(buf, &xprt->addr, bytes);
 	rcu_read_unlock();
 	return bytes;
 }
 EXPORT_SYMBOL_GPL(rpc_peeraddr);
 /**
  * rpc_peeraddr2str - return remote peer address in printable format
  * @clnt: RPC client structure
  * @format: address format
  *
  * NB: the lifetime of the memory referenced by the returned pointer is
  * the same as the rpc_xprt itself.  As long as the caller uses this
  * pointer, it must hold the RCU read lock.
  */
 const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
 			     enum rpc_display_format_t format)
 {
 	struct rpc_xprt *xprt;
 	xprt = rcu_dereference(clnt->cl_xprt);
 	if (xprt->address_strings[format] != NULL)
 		return xprt->address_strings[format];
 	else
 		return "unprintable";
 }
 EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
 static const struct sockaddr_in rpc_inaddr_loopback = {
 	.sin_family		= AF_INET,
 	.sin_addr.s_addr	= htonl(INADDR_ANY),
 };
 static const struct sockaddr_in6 rpc_in6addr_loopback = {
 	.sin6_family		= AF_INET6,
 	.sin6_addr		= IN6ADDR_ANY_INIT,
 };
 /*
  * Try a getsockname() on a connected datagram socket.  Using a
  * connected datagram socket prevents leaving a socket in TIME_WAIT.
  * This conserves the ephemeral port number space.
  *
  * Returns zero and fills in "buf" if successful; otherwise, a
  * negative errno is returned.
  */
 static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
 			struct sockaddr *buf, int buflen)
 {
 	struct socket *sock;
 	int err;
 	err = __sock_create(net, sap->sa_family,
 				SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
 	if (err < 0) {
 		dprintk("RPC:       can't create UDP socket (%d)\n", err);
 		goto out;
 	}
 	switch (sap->sa_family) {
 	case AF_INET:
 		err = kernel_bind(sock,
 				(struct sockaddr *)&rpc_inaddr_loopback,
 				sizeof(rpc_inaddr_loopback));
 		break;
 	case AF_INET6:
 		err = kernel_bind(sock,
 				(struct sockaddr *)&rpc_in6addr_loopback,
 				sizeof(rpc_in6addr_loopback));
 		break;
 	default:
 		err = -EAFNOSUPPORT;
 		goto out;
 	}
 	if (err < 0) {
 		dprintk("RPC:       can't bind UDP socket (%d)\n", err);
 		goto out_release;
 	}
 	err = kernel_connect(sock, sap, salen, 0);
 	if (err < 0) {
 		dprintk("RPC:       can't connect UDP socket (%d)\n", err);
 		goto out_release;
 	}
 	err = kernel_getsockname(sock, buf, &buflen);
 	if (err < 0) {
 		dprintk("RPC:       getsockname failed (%d)\n", err);
 		goto out_release;
 	}
 	err = 0;
 	if (buf->sa_family == AF_INET6) {
 		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
 		sin6->sin6_scope_id = 0;
 	}
 	dprintk("RPC:       %s succeeded\n", __func__);
 out_release:
 	sock_release(sock);
 out:
 	return err;
 }
 /*
  * Scraping a connected socket failed, so we don't have a useable
  * local address.  Fallback: generate an address that will prevent
  * the server from calling us back.
  *
  * Returns zero and fills in "buf" if successful; otherwise, a
  * negative errno is returned.
  */
 static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
 {
 	switch (family) {
 	case AF_INET:
 		if (buflen < sizeof(rpc_inaddr_loopback))
 			return -EINVAL;
 		memcpy(buf, &rpc_inaddr_loopback,
 				sizeof(rpc_inaddr_loopback));
 		break;
 	case AF_INET6:
 		if (buflen < sizeof(rpc_in6addr_loopback))
 			return -EINVAL;
 		memcpy(buf, &rpc_in6addr_loopback,
 				sizeof(rpc_in6addr_loopback));
 	default:
 		dprintk("RPC:       %s: address family not supported\n",
 			__func__);
 		return -EAFNOSUPPORT;
 	}
 	dprintk("RPC:       %s: succeeded\n", __func__);
 	return 0;
 }
 /**
  * rpc_localaddr - discover local endpoint address for an RPC client
  * @clnt: RPC client structure
  * @buf: target buffer
  * @buflen: size of target buffer, in bytes
  *
  * Returns zero and fills in "buf" and "buflen" if successful;
  * otherwise, a negative errno is returned.
  *
  * This works even if the underlying transport is not currently connected,
  * or if the upper layer never previously provided a source address.
  *
  * The result of this function call is transient: multiple calls in
  * succession may give different results, depending on how local
  * networking configuration changes over time.
  */
 int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
 {
 	struct sockaddr_storage address;
 	struct sockaddr *sap = (struct sockaddr *)&address;
 	struct rpc_xprt *xprt;
 	struct net *net;
 	size_t salen;
 	int err;
 	rcu_read_lock();
 	xprt = rcu_dereference(clnt->cl_xprt);
 	salen = xprt->addrlen;
 	memcpy(sap, &xprt->addr, salen);
 	net = get_net(xprt->xprt_net);
 	rcu_read_unlock();
 	rpc_set_port(sap, 0);
 	err = rpc_sockname(net, sap, salen, buf, buflen);
 	put_net(net);
 	if (err != 0)
 		/* Couldn't discover local address, return ANYADDR */
 		return rpc_anyaddr(sap->sa_family, buf, buflen);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(rpc_localaddr);
 void
 rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
 {
 	struct rpc_xprt *xprt;
 	rcu_read_lock();
 	xprt = rcu_dereference(clnt->cl_xprt);
 	if (xprt->ops->set_buffer_size)
 		xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
 	rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(rpc_setbufsize);
 /**
  * rpc_protocol - Get transport protocol number for an RPC client
  * @clnt: RPC client to query
  *
  */
 int rpc_protocol(struct rpc_clnt *clnt)
 {
 	int protocol;
 	rcu_read_lock();
 	protocol = rcu_dereference(clnt->cl_xprt)->prot;
 	rcu_read_unlock();
 	return protocol;
 }
 EXPORT_SYMBOL_GPL(rpc_protocol);
 /**
  * rpc_net_ns - Get the network namespace for this RPC client
  * @clnt: RPC client to query
  *
  */
 struct net *rpc_net_ns(struct rpc_clnt *clnt)
 {
 	struct net *ret;
 	rcu_read_lock();
 	ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
 	rcu_read_unlock();
 	return ret;
 }
 EXPORT_SYMBOL_GPL(rpc_net_ns);
 /**
  * rpc_max_payload - Get maximum payload size for a transport, in bytes
  * @clnt: RPC client to query
  *
  * For stream transports, this is one RPC record fragment (see RFC
  * 1831), as we don't support multi-record requests yet.  For datagram
  * transports, this is the size of an IP packet minus the IP, UDP, and
  * RPC header sizes.
  */
 size_t rpc_max_payload(struct rpc_clnt *clnt)
 {
 	size_t ret;
 	rcu_read_lock();
 	ret = rcu_dereference(clnt->cl_xprt)->max_payload;
 	rcu_read_unlock();
 	return ret;
 }
 EXPORT_SYMBOL_GPL(rpc_max_payload);
 /**
  * rpc_get_timeout - Get timeout for transport in units of HZ
  * @clnt: RPC client to query
  */
 unsigned long rpc_get_timeout(struct rpc_clnt *clnt)
 {
 	unsigned long ret;
 	rcu_read_lock();
 	ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;
 	rcu_read_unlock();
 	return ret;
 }
 EXPORT_SYMBOL_GPL(rpc_get_timeout);
 /**
  * rpc_force_rebind - force transport to check that remote port is unchanged
  * @clnt: client to rebind
  *
  */
 void rpc_force_rebind(struct rpc_clnt *clnt)
 {
 	if (clnt->cl_autobind) {
 		rcu_read_lock();
 		xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
 		rcu_read_unlock();
 	}
 }
 EXPORT_SYMBOL_GPL(rpc_force_rebind);
 /*
  * Restart an (async) RPC call from the call_prepare state.
  * Usually called from within the exit handler.
  */
 int
 rpc_restart_call_prepare(struct rpc_task *task)
 {
 	if (RPC_ASSASSINATED(task))
 		return 0;
 	task->tk_action = call_start;
 	if (task->tk_ops->rpc_call_prepare != NULL)
 		task->tk_action = rpc_prepare_task;
 	return 1;
 }
 EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
 /*
  * Restart an (async) RPC call. Usually called from within the
  * exit handler.
  */
 int
 rpc_restart_call(struct rpc_task *task)
 {
 	if (RPC_ASSASSINATED(task))
 		return 0;
 	task->tk_action = call_start;
 	return 1;
 }
 EXPORT_SYMBOL_GPL(rpc_restart_call);
 #ifdef RPC_DEBUG
 static const char *rpc_proc_name(const struct rpc_task *task)
 {
 	const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
 	if (proc) {
 		if (proc->p_name)
 			return proc->p_name;
 		else
 			return "NULL";
 	} else
 		return "no proc";
 }
 #endif
 /*
  * 0.  Initial state
  *
  *     Other FSM states can be visited zero or more times, but
  *     this state is visited exactly once for each RPC.
  */
 static void
 call_start(struct rpc_task *task)
 {
 	struct rpc_clnt	*clnt = task->tk_client;
 	dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
 			clnt->cl_program->name, clnt->cl_vers,
 			rpc_proc_name(task),
 			(RPC_IS_ASYNC(task) ? "async" : "sync"));
 	/* Increment call count */
 	task->tk_msg.rpc_proc->p_count++;
 	clnt->cl_stats->rpccnt++;
 	task->tk_action = call_reserve;
 }
 /*
  * 1.	Reserve an RPC call slot
  */
 static void
 call_reserve(struct rpc_task *task)
 {
 	dprint_status(task);
 	task->tk_status  = 0;
 	task->tk_action  = call_reserveresult;
 	xprt_reserve(task);
 }
 static void call_retry_reserve(struct rpc_task *task);
 /*
  * 1b.	Grok the result of xprt_reserve()
  */
 static void
 call_reserveresult(struct rpc_task *task)
 {
 	int status = task->tk_status;
 	dprint_status(task);
 	/*
 	 * After a call to xprt_reserve(), we must have either
 	 * a request slot or else an error status.
 	 */
 	task->tk_status = 0;
 	if (status >= 0) {
 		if (task->tk_rqstp) {
 			task->tk_action = call_refresh;
 			return;
 		}
 		printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",
 				__func__, status);
 		rpc_exit(task, -EIO);
 		return;
 	}
 	/*
 	 * Even though there was an error, we may have acquired
 	 * a request slot somehow.  Make sure not to leak it.
 	 */
 	if (task->tk_rqstp) {
 		printk(KERN_ERR "%s: status=%d, request allocated anyway\n",
 				__func__, status);
 		xprt_release(task);
 	}
 	switch (status) {
 	case -ENOMEM:
 		rpc_delay(task, HZ >> 2);
 	case -EAGAIN:	/* woken up; retry */
 		task->tk_action = call_retry_reserve;
 		return;
 	case -EIO:	/* probably a shutdown */
 		break;
 	default:
 		printk(KERN_ERR "%s: unrecognized error %d, exiting\n",
 				__func__, status);
 		break;
 	}
 	rpc_exit(task, status);
 }
 /*
  * 1c.	Retry reserving an RPC call slot
  */
 static void
 call_retry_reserve(struct rpc_task *task)
 {
 	dprint_status(task);
 	task->tk_status  = 0;
 	task->tk_action  = call_reserveresult;
 	xprt_retry_reserve(task);
 }
 /*
  * 2.	Bind and/or refresh the credentials
  */
 static void
 call_refresh(struct rpc_task *task)
 {
 	dprint_status(task);
 	task->tk_action = call_refreshresult;
 	task->tk_status = 0;
 	task->tk_client->cl_stats->rpcauthrefresh++;
 	rpcauth_refreshcred(task);
 }
 /*
  * 2a.	Process the results of a credential refresh
  */
 static void
 call_refreshresult(struct rpc_task *task)
 {
 	int status = task->tk_status;
 	dprint_status(task);
 	task->tk_status = 0;
 	task->tk_action = call_refresh;
 	switch (status) {
 	case 0:
 		if (rpcauth_uptodatecred(task)) {
 			task->tk_action = call_allocate;
 			return;
 		}
 		/* Use rate-limiting and a max number of retries if refresh
 		 * had status 0 but failed to update the cred.
 		 */
 	case -ETIMEDOUT:
 		rpc_delay(task, 3*HZ);
 	case -EAGAIN:
 		status = -EACCES;
 	case -EKEYEXPIRED:
 		if (!task->tk_cred_retry)
 			break;
 		task->tk_cred_retry--;
 		dprintk("RPC: %5u %s: retry refresh creds\n",
 				task->tk_pid, __func__);
 		return;
 	}
 	dprintk("RPC: %5u %s: refresh creds failed with error %d\n",
 				task->tk_pid, __func__, status);
 	rpc_exit(task, status);
 }
 /*
  * 2b.	Allocate the buffer. For details, see sched.c:rpc_malloc.
  *	(Note: buffer memory is freed in xprt_release).
  */
 static void
 call_allocate(struct rpc_task *task)
 {
 	unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;
 	struct rpc_rqst *req = task->tk_rqstp;
 	struct rpc_xprt *xprt = req->rq_xprt;
 	struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
 	dprint_status(task);
 	task->tk_status = 0;
 	task->tk_action = call_bind;
 	if (req->rq_buffer)
 		return;
 	if (proc->p_proc != 0) {
 		BUG_ON(proc->p_arglen == 0);
 		if (proc->p_decode != NULL)
 			BUG_ON(proc->p_replen == 0);
 	}
 	/*
 	 * Calculate the size (in quads) of the RPC call
 	 * and reply headers, and convert both values
 	 * to byte sizes.
 	 */
 	req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;
 	req->rq_callsize <<= 2;
 	req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;
 	req->rq_rcvsize <<= 2;
 	req->rq_buffer = xprt->ops->buf_alloc(task,
 					req->rq_callsize + req->rq_rcvsize);
 	if (req->rq_buffer != NULL)
 		return;
 	dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
 	if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
 		task->tk_action = call_allocate;
 		rpc_delay(task, HZ>>4);
 		return;
 	}
 	rpc_exit(task, -ERESTARTSYS);
 }
 static inline int
 rpc_task_need_encode(struct rpc_task *task)
 {
 	return task->tk_rqstp->rq_snd_buf.len == 0;
 }
 static inline void
 rpc_task_force_reencode(struct rpc_task *task)
 {
 	task->tk_rqstp->rq_snd_buf.len = 0;
 	task->tk_rqstp->rq_bytes_sent = 0;
 }
 static inline void
 rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
 {
 	buf->head[0].iov_base = start;
 	buf->head[0].iov_len = len;
 	buf->tail[0].iov_len = 0;
 	buf->page_len = 0;
 	buf->flags = 0;
 	buf->len = 0;
 	buf->buflen = len;
 }
 /*
  * 3.	Encode arguments of an RPC call
  */
 static void
 rpc_xdr_encode(struct rpc_task *task)
 {
 	struct rpc_rqst	*req = task->tk_rqstp;
 	kxdreproc_t	encode;
 	__be32		*p;
 	dprint_status(task);
 	rpc_xdr_buf_init(&req->rq_snd_buf,
 			 req->rq_buffer,
 			 req->rq_callsize);
 	rpc_xdr_buf_init(&req->rq_rcv_buf,
 			 (char *)req->rq_buffer + req->rq_callsize,
 			 req->rq_rcvsize);
 	p = rpc_encode_header(task);
 	if (p == NULL) {
 		printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
 		rpc_exit(task, -EIO);
 		return;
 	}
 	encode = task->tk_msg.rpc_proc->p_encode;
 	if (encode == NULL)
 		return;
 	task->tk_status = rpcauth_wrap_req(task, encode, req, p,
 			task->tk_msg.rpc_argp);
 }
 /*
  * 4.	Get the server port number if not yet set
  */
 static void
 call_bind(struct rpc_task *task)
 {
 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
 	dprint_status(task);
 	task->tk_action = call_connect;
 	if (!xprt_bound(xprt)) {
 		task->tk_action = call_bind_status;
 		task->tk_timeout = xprt->bind_timeout;
 		xprt->ops->rpcbind(task);
 	}
 }
 /*
  * 4a.	Sort out bind result
  */
 static void
 call_bind_status(struct rpc_task *task)
 {
 	int status = -EIO;
 	if (task->tk_status >= 0) {
 		dprint_status(task);
 		task->tk_status = 0;
 		task->tk_action = call_connect;
 		return;
 	}
 	trace_rpc_bind_status(task);
 	switch (task->tk_status) {
 	case -ENOMEM:
 		dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
 		rpc_delay(task, HZ >> 2);
 		goto retry_timeout;
 	case -EACCES:
 		dprintk("RPC: %5u remote rpcbind: RPC program/version "
 				"unavailable\n", task->tk_pid);
 		/* fail immediately if this is an RPC ping */
 		if (task->tk_msg.rpc_proc->p_proc == 0) {
 			status = -EOPNOTSUPP;
 			break;
 		}
 		if (task->tk_rebind_retry == 0)
 			break;
 		task->tk_rebind_retry--;
 		rpc_delay(task, 3*HZ);
 		goto retry_timeout;
 	case -ETIMEDOUT:
 		dprintk("RPC: %5u rpcbind request timed out\n",
 				task->tk_pid);
 		goto retry_timeout;
 	case -EPFNOSUPPORT:
 		/* server doesn't support any rpcbind version we know of */
 		dprintk("RPC: %5u unrecognized remote rpcbind service\n",
 				task->tk_pid);
 		break;
 	case -EPROTONOSUPPORT:
 		dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
 				task->tk_pid);
 		task->tk_status = 0;
 		task->tk_action = call_bind;
 		return;
 	case -ECONNREFUSED:		/* connection problems */
 	case -ECONNRESET:
 	case -ECONNABORTED:
 	case -ENOTCONN:
 	case -EHOSTDOWN:
 	case -EHOSTUNREACH:
 	case -ENETUNREACH:
 	case -EPIPE:
 		dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
 				task->tk_pid, task->tk_status);
 		if (!RPC_IS_SOFTCONN(task)) {
 			rpc_delay(task, 5*HZ);
 			goto retry_timeout;
 		}
 		status = task->tk_status;
 		break;
 	default:
 		dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
 				task->tk_pid, -task->tk_status);
 	}
 	rpc_exit(task, status);
 	return;
 retry_timeout:
 	task->tk_action = call_timeout;
 }
 /*
  * 4b.	Connect to the RPC server
  */
 static void
 call_connect(struct rpc_task *task)
 {
 	struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
 	dprintk("RPC: %5u call_connect xprt %p %s connected\n",
 			task->tk_pid, xprt,
 			(xprt_connected(xprt) ? "is" : "is not"));
 	task->tk_action = call_transmit;
 	if (!xprt_connected(xprt)) {
 		task->tk_action = call_connect_status;
 		if (task->tk_status < 0)
 			return;
 		if (task->tk_flags & RPC_TASK_NOCONNECT) {
 			rpc_exit(task, -ENOTCONN);
 			return;
 		}
 		xprt_connect(task);
 	}
 }
 /*
  * 4c.	Sort out connect result
  */
 static void
 call_connect_status(struct rpc_task *task)
 {
 	struct rpc_clnt *clnt = task->tk_client;
 	int status = task->tk_status;
 	dprint_status(task);
 	trace_rpc_connect_status(task, status);
 	task->tk_status = 0;
 	switch (status) {
 	case -ECONNREFUSED:
 	case -ECONNRESET:
 	case -ECONNABORTED:
 	case -ENETUNREACH:
 	case -EHOSTUNREACH:
-		/* retry with existing socket, after a delay */
-		rpc_delay(task, 3*HZ);
 		if (RPC_IS_SOFTCONN(task))
 			break;
+		/* retry with existing socket, after a delay */
+		rpc_delay(task, 3*HZ);
 	case -EAGAIN:
 		/* Check for timeouts before looping back to call_bind */
 	case -ETIMEDOUT:
 		task->tk_action = call_timeout;
 		return;
 	case 0:
 		clnt->cl_stats->netreconn++;
 		task->tk_action = call_transmit;
 		return;
 	}
 	rpc_exit(task, status);
 }
 /*
  * 5.	Transmit the RPC request, and wait for reply
  */
 static void
 call_transmit(struct rpc_task *task)
 {
 	int is_retrans = RPC_WAS_SENT(task);
 	dprint_status(task);
 	task->tk_action = call_status;
 	if (task->tk_status < 0)
 		return;
 	if (!xprt_prepare_transmit(task))
 		return;
 	task->tk_action = call_transmit_status;
 	/* Encode here so that rpcsec_gss can use correct sequence number. */
 	if (rpc_task_need_encode(task)) {
 		rpc_xdr_encode(task);
 		/* Did the encode result in an error condition? */
 		if (task->tk_status != 0) {
 			/* Was the error nonfatal? */
 			if (task->tk_status == -EAGAIN)
 				rpc_delay(task, HZ >> 4);
 			else
 				rpc_exit(task, task->tk_status);
 			return;
 		}
 	}
 	xprt_transmit(task);
 	if (task->tk_status < 0)
 		return;
 	if (is_retrans)
 		task->tk_client->cl_stats->rpcretrans++;
 	/*
 	 * On success, ensure that we call xprt_end_transmit() before sleeping
 	 * in order to allow access to the socket to other RPC requests.
 	 */
 	call_transmit_status(task);
 	if (rpc_reply_expected(task))
 		return;
 	task->tk_action = rpc_exit_task;
 	rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);
 }
 /*
  * 5a.	Handle cleanup after a transmission
  */
 static void
 call_transmit_status(struct rpc_task *task)
 {
 	task->tk_action = call_status;
 	/*
 	 * Common case: success.  Force the compiler to put this
 	 * test first.
 	 */
 	if (task->tk_status == 0) {
 		xprt_end_transmit(task);
 		rpc_task_force_reencode(task);
 		return;
 	}
 	switch (task->tk_status) {
 	case -EAGAIN:
 		break;
 	default:
 		dprint_status(task);
 		xprt_end_transmit(task);
 		rpc_task_force_reencode(task);
 		break;
 		/*
 		 * Special cases: if we've been waiting on the
 		 * socket's write_space() callback, or if the
 		 * socket just returned a connection error,
 		 * then hold onto the transport lock.
 		 */
 	case -ECONNREFUSED:
 	case -EHOSTDOWN:
 	case -EHOSTUNREACH:
 	case -ENETUNREACH:
 		if (RPC_IS_SOFTCONN(task)) {
 			xprt_end_transmit(task);
 			rpc_exit(task, task->tk_status);
 			break;
 		}
 	case -ECONNRESET:
 	case -ECONNABORTED:
 	case -ENOTCONN:
 	case -EPIPE:
 		rpc_task_force_reencode(task);
 	}
 }
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /*
  * 5b.	Send the backchannel RPC reply.  On error, drop the reply.  In
  * addition, disconnect on connectivity errors.
  */
 static void
 call_bc_transmit(struct rpc_task *task)
 {
 	struct rpc_rqst *req = task->tk_rqstp;
 	if (!xprt_prepare_transmit(task)) {
 		/*
 		 * Could not reserve the transport. Try again after the
 		 * transport is released.
 		 */
 		task->tk_status = 0;
 		task->tk_action = call_bc_transmit;
 		return;
 	}
 	task->tk_action = rpc_exit_task;
 	if (task->tk_status < 0) {
 		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
 			"error: %d\n", task->tk_status);
 		return;
 	}
 	xprt_transmit(task);
 	xprt_end_transmit(task);
 	dprint_status(task);
 	switch (task->tk_status) {
 	case 0:
 		/* Success */
 		break;
 	case -EHOSTDOWN:
 	case -EHOSTUNREACH:
 	case -ENETUNREACH:
 	case -ETIMEDOUT:
 		/*
 		 * Problem reaching the server.  Disconnect and let the
 		 * forechannel reestablish the connection.  The server will
 		 * have to retransmit the backchannel request and we'll
 		 * reprocess it.  Since these ops are idempotent, there's no
 		 * need to cache our reply at this time.
 		 */
 		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
 			"error: %d\n", task->tk_status);
 		xprt_conditional_disconnect(req->rq_xprt,
 			req->rq_connect_cookie);
 		break;
 	default:
 		/*
 		 * We were unable to reply and will have to drop the
 		 * request.  The server should reconnect and retransmit.
 		 */
 		WARN_ON_ONCE(task->tk_status == -EAGAIN);
 		printk(KERN_NOTICE "RPC: Could not send backchannel reply "
 			"error: %d\n", task->tk_status);
 		break;
 	}
 	rpc_wake_up_queued_task(&req->rq_xprt->pending, task);
 }
 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
 /*
  * 6.	Sort out the RPC call status
  */
 static void
 call_status(struct rpc_task *task)
 {
 	struct rpc_clnt	*clnt = task->tk_client;
 	struct rpc_rqst	*req = task->tk_rqstp;
 	int		status;
 	if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)
 		task->tk_status = req->rq_reply_bytes_recvd;
 	dprint_status(task);
 	status = task->tk_status;
 	if (status >= 0) {
 		task->tk_action = call_decode;
 		return;
 	}
 	trace_rpc_call_status(task);
 	task->tk_status = 0;
 	switch(status) {
 	case -EHOSTDOWN:
 	case -EHOSTUNREACH:
 	case -ENETUNREACH:
 		/*
 		 * Delay any retries for 3 seconds, then handle as if it
 		 * were a timeout.
 		 */
 		rpc_delay(task, 3*HZ);
 	case -ETIMEDOUT:
 		task->tk_action = call_timeout;
 		if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
 		    && task->tk_client->cl_discrtry)
 			xprt_conditional_disconnect(req->rq_xprt,
 					req->rq_connect_cookie);
 		break;
 	case -ECONNREFUSED:
 	case -ECONNRESET:
 	case -ECONNABORTED:
 		rpc_force_rebind(clnt);
 		rpc_delay(task, 3*HZ);
 	case -EPIPE:
 	case -ENOTCONN:
 		task->tk_action = call_bind;
 		break;
 	case -EAGAIN:
 		task->tk_action = call_transmit;
 		break;
 	case -EIO:
 		/* shutdown or soft timeout */
 		rpc_exit(task, status);
 		break;
 	default:
 		if (clnt->cl_chatty)
 			printk("%s: RPC call returned error %d\n",
 			       clnt->cl_program->name, -status);
 		rpc_exit(task, status);
 	}
 }
 /*
  * 6a.	Handle RPC timeout
  * 	We do not release the request slot, so we keep using the
  *	same XID for all retransmits.
  */
 static void
 call_timeout(struct rpc_task *task)
 {
 	struct rpc_clnt	*clnt = task->tk_client;
 	if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
 		dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
 		goto retry;
 	}
 	dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
 	task->tk_timeouts++;
 	if (RPC_IS_SOFTCONN(task)) {
 		rpc_exit(task, -ETIMEDOUT);
 		return;
 	}
 	if (RPC_IS_SOFT(task)) {
 		if (clnt->cl_chatty) {
 			rcu_read_lock();
 			printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
 				clnt->cl_program->name,
 				rcu_dereference(clnt->cl_xprt)->servername);
 			rcu_read_unlock();
 		}
 		if (task->tk_flags & RPC_TASK_TIMEOUT)
 			rpc_exit(task, -ETIMEDOUT);
 		else
 			rpc_exit(task, -EIO);
 		return;
 	}
 	if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
 		task->tk_flags |= RPC_CALL_MAJORSEEN;
 		if (clnt->cl_chatty) {
 			rcu_read_lock();
 			printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
 			clnt->cl_program->name,
 			rcu_dereference(clnt->cl_xprt)->servername);
 			rcu_read_unlock();
 		}
 	}
 	rpc_force_rebind(clnt);
 	/*
 	 * Did our request time out due to an RPCSEC_GSS out-of-sequence
 	 * event? RFC2203 requires the server to drop all such requests.
 	 */
 	rpcauth_invalcred(task);
 retry:
 	task->tk_action = call_bind;
 	task->tk_status = 0;
 }
 /*
  * 7.	Decode the RPC reply
  */
 static void
 call_decode(struct rpc_task *task)
 {
 	struct rpc_clnt	*clnt = task->tk_client;
 	struct rpc_rqst	*req = task->tk_rqstp;
 	kxdrdproc_t	decode = task->tk_msg.rpc_proc->p_decode;
 	__be32		*p;
 	dprint_status(task);
 	if (task->tk_flags & RPC_CALL_MAJORSEEN) {
 		if (clnt->cl_chatty) {
 			rcu_read_lock();
 			printk(KERN_NOTICE "%s: server %s OK\n",
 				clnt->cl_program->name,
 				rcu_dereference(clnt->cl_xprt)->servername);
 			rcu_read_unlock();
 		}
 		task->tk_flags &= ~RPC_CALL_MAJORSEEN;
 	}
 	/*
 	 * Ensure that we see all writes made by xprt_complete_rqst()
 	 * before it changed req->rq_reply_bytes_recvd.
 	 */
 	smp_rmb();
 	req->rq_rcv_buf.len = req->rq_private_buf.len;
 	/* Check that the softirq receive buffer is valid */
 	WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
 				sizeof(req->rq_rcv_buf)) != 0);
 	if (req->rq_rcv_buf.len < 12) {
 		if (!RPC_IS_SOFT(task)) {
 			task->tk_action = call_bind;
 			goto out_retry;
 		}
 		dprintk("RPC:       %s: too small RPC reply size (%d bytes)\n",
 				clnt->cl_program->name, task->tk_status);
 		task->tk_action = call_timeout;
 		goto out_retry;
 	}
 	p = rpc_verify_header(task);
 	if (IS_ERR(p)) {
 		if (p == ERR_PTR(-EAGAIN))
 			goto out_retry;
 		return;
 	}
 	task->tk_action = rpc_exit_task;
 	if (decode) {
 		task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
 						      task->tk_msg.rpc_resp);
 	}
 	dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
 			task->tk_status);
 	return;
 out_retry:
 	task->tk_status = 0;
 	/* Note: rpc_verify_header() may have freed the RPC slot */
 	if (task->tk_rqstp == req) {
 		req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
 		if (task->tk_client->cl_discrtry)
 			xprt_conditional_disconnect(req->rq_xprt,
 					req->rq_connect_cookie);
 	}
 }
 static __be32 *
 rpc_encode_header(struct rpc_task *task)
 {
 	struct rpc_clnt *clnt = task->tk_client;
 	struct rpc_rqst	*req = task->tk_rqstp;
 	__be32		*p = req->rq_svec[0].iov_base;
 	/* FIXME: check buffer size? */
 	p = xprt_skip_transport_header(req->rq_xprt, p);
 	*p++ = req->rq_xid;		/* XID */
 	*p++ = htonl(RPC_CALL);		/* CALL */
 	*p++ = htonl(RPC_VERSION);	/* RPC version */
 	*p++ = htonl(clnt->cl_prog);	/* program number */
 	*p++ = htonl(clnt->cl_vers);	/* program version */
 	*p++ = htonl(task->tk_msg.rpc_proc->p_proc);	/* procedure */
 	p = rpcauth_marshcred(task, p);
 	req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
 	return p;
 }
 static __be32 *
 rpc_verify_header(struct rpc_task *task)
 {
 	struct rpc_clnt *clnt = task->tk_client;
 	struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
 	int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
 	__be32	*p = iov->iov_base;
 	u32 n;
 	int error = -EACCES;
 	if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
 		/* RFC-1014 says that the representation of XDR data must be a
 		 * multiple of four bytes
 		 * - if it isn't pointer subtraction in the NFS client may give
 		 *   undefined results
 		 */
 		dprintk("RPC: %5u %s: XDR representation not a multiple of"
 		       " 4 bytes: 0x%x\n", task->tk_pid, __func__,
 		       task->tk_rqstp->rq_rcv_buf.len);
 		error = -EIO;
 		goto out_err;
 	}
 	if ((len -= 3) < 0)
 		goto out_overflow;
 	p += 1; /* skip XID */
 	if ((n = ntohl(*p++)) != RPC_REPLY) {
 		dprintk("RPC: %5u %s: not an RPC reply: %x\n",
 			task->tk_pid, __func__, n);
 		error = -EIO;
 		goto out_garbage;
 	}
 	if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
 		if (--len < 0)
 			goto out_overflow;
 		switch ((n = ntohl(*p++))) {
 		case RPC_AUTH_ERROR:
 			break;
 		case RPC_MISMATCH:
 			dprintk("RPC: %5u %s: RPC call version mismatch!\n",
 				task->tk_pid, __func__);
 			error = -EPROTONOSUPPORT;
 			goto out_err;
 		default:
 			dprintk("RPC: %5u %s: RPC call rejected, "
 				"unknown error: %x\n",
 				task->tk_pid, __func__, n);
 			error = -EIO;
 			goto out_err;
 		}
 		if (--len < 0)
 			goto out_overflow;
 		switch ((n = ntohl(*p++))) {
 		case RPC_AUTH_REJECTEDCRED:
 		case RPC_AUTH_REJECTEDVERF:
 		case RPCSEC_GSS_CREDPROBLEM:
 		case RPCSEC_GSS_CTXPROBLEM:
 			if (!task->tk_cred_retry)
 				break;
 			task->tk_cred_retry--;
 			dprintk("RPC: %5u %s: retry stale creds\n",
 					task->tk_pid, __func__);
 			rpcauth_invalcred(task);
 			/* Ensure we obtain a new XID! */
 			xprt_release(task);
 			task->tk_action = call_reserve;
 			goto out_retry;
 		case RPC_AUTH_BADCRED:
 		case RPC_AUTH_BADVERF:
 			/* possibly garbled cred/verf? */
 			if (!task->tk_garb_retry)
 				break;
 			task->tk_garb_retry--;
 			dprintk("RPC: %5u %s: retry garbled creds\n",
 					task->tk_pid, __func__);
 			task->tk_action = call_bind;
 			goto out_retry;
 		case RPC_AUTH_TOOWEAK:
 			rcu_read_lock();
 			printk(KERN_NOTICE "RPC: server %s requires stronger "
 			       "authentication.\n",
 			       rcu_dereference(clnt->cl_xprt)->servername);
 			rcu_read_unlock();
 			break;
 		default:
 			dprintk("RPC: %5u %s: unknown auth error: %x\n",
 					task->tk_pid, __func__, n);
 			error = -EIO;
 		}
 		dprintk("RPC: %5u %s: call rejected %d\n",
 				task->tk_pid, __func__, n);
 		goto out_err;
 	}
 	p = rpcauth_checkverf(task, p);
 	if (IS_ERR(p)) {
 		error = PTR_ERR(p);
 		dprintk("RPC: %5u %s: auth check failed with %d\n",
 				task->tk_pid, __func__, error);
 		goto out_garbage;		/* bad verifier, retry */
 	}
 	len = p - (__be32 *)iov->iov_base - 1;
 	if (len < 0)
 		goto out_overflow;
 	switch ((n = ntohl(*p++))) {
 	case RPC_SUCCESS:
 		return p;
 	case RPC_PROG_UNAVAIL:
 		dprintk_rcu("RPC: %5u %s: program %u is unsupported "
 				"by server %s\n", task->tk_pid, __func__,
 				(unsigned int)clnt->cl_prog,
 				rcu_dereference(clnt->cl_xprt)->servername);
 		error = -EPFNOSUPPORT;
 		goto out_err;
 	case RPC_PROG_MISMATCH:
 		dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "
 				"by server %s\n", task->tk_pid, __func__,
 				(unsigned int)clnt->cl_prog,
 				(unsigned int)clnt->cl_vers,
 				rcu_dereference(clnt->cl_xprt)->servername);
 		error = -EPROTONOSUPPORT;
 		goto out_err;
 	case RPC_PROC_UNAVAIL:
 		dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "
 				"version %u on server %s\n",
 				task->tk_pid, __func__,
 				rpc_proc_name(task),
 				clnt->cl_prog, clnt->cl_vers,
 				rcu_dereference(clnt->cl_xprt)->servername);
 		error = -EOPNOTSUPP;
 		goto out_err;
 	case RPC_GARBAGE_ARGS:
 		dprintk("RPC: %5u %s: server saw garbage\n",
 				task->tk_pid, __func__);
 		break;			/* retry */
 	default:
 		dprintk("RPC: %5u %s: server accept status: %x\n",
 				task->tk_pid, __func__, n);
 		/* Also retry */
 	}
 out_garbage:
 	clnt->cl_stats->rpcgarbage++;
 	if (task->tk_garb_retry) {
 		task->tk_garb_retry--;
 		dprintk("RPC: %5u %s: retrying\n",
 				task->tk_pid, __func__);
 		task->tk_action = call_bind;
 out_retry:
 		return ERR_PTR(-EAGAIN);
 	}
 out_err:
 	rpc_exit(task, error);
 	dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,
 			__func__, error);
 	return ERR_PTR(error);
 out_overflow:
 	dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,
 			__func__);
 	goto out_garbage;
 }
 static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
 {
 }
 static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
 {
 	return 0;
 }
 static struct rpc_procinfo rpcproc_null = {
 	.p_encode = rpcproc_encode_null,
 	.p_decode = rpcproc_decode_null,
 };
 static int rpc_ping(struct rpc_clnt *clnt)
 {
 	struct rpc_message msg = {
 		.rpc_proc = &rpcproc_null,
 	};
 	int err;
 	msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);
 	err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
 	put_rpccred(msg.rpc_cred);
 	return err;
 }
 struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
 {
 	struct rpc_message msg = {
 		.rpc_proc = &rpcproc_null,
 		.rpc_cred = cred,
 	};
 	struct rpc_task_setup task_setup_data = {
 		.rpc_client = clnt,
 		.rpc_message = &msg,
 		.callback_ops = &rpc_default_ops,
 		.flags = flags,
 	};
 	return rpc_run_task(&task_setup_data);
 }
 EXPORT_SYMBOL_GPL(rpc_call_null);
 #ifdef RPC_DEBUG
 static void rpc_show_header(void)
 {
 	printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
 		"-timeout ---ops--\n");
 }
 static void rpc_show_task(const struct rpc_clnt *clnt,
 			  const struct rpc_task *task)
 {
 	const char *rpc_waitq = "none";
 	if (RPC_IS_QUEUED(task))
 		rpc_waitq = rpc_qname(task->tk_waitqueue);
 	printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
 		task->tk_pid, task->tk_flags, task->tk_status,
 		clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
 		clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
 		task->tk_action, rpc_waitq);
 }
 void rpc_show_tasks(struct net *net)
 {
 	struct rpc_clnt *clnt;
 	struct rpc_task *task;
 	int header = 0;
 	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 	spin_lock(&sn->rpc_client_lock);
 	list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
 		spin_lock(&clnt->cl_lock);
 		list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
 			if (!header) {
 				rpc_show_header();
 				header++;
 			}
 			rpc_show_task(clnt, task);
 		}
 		spin_unlock(&clnt->cl_lock);
 	}
 	spin_unlock(&sn->rpc_client_lock);
 }