Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* fs/nfs/nfs4proc.c

2

* fs/nfs/nfs4proc.c

3

*

3

*

4

* Client-side procedure declarations for NFSv4.

4

* Client-side procedure declarations for NFSv4.

5

*

5

*

6

7

8

*

8

*

9

* Kendrick Smith <kmsmith@umich.edu>

9

* Kendrick Smith <kmsmith@umich.edu>

10

* Andy Adamson <andros@umich.edu>

10

* Andy Adamson <andros@umich.edu>

11

*

11

*

12

* Redistribution and use in source and binary forms, with or without

12

* Redistribution and use in source and binary forms, with or without

13

* modification, are permitted provided that the following conditions

13

* modification, are permitted provided that the following conditions

14

* are met:

14

* are met:

15

*

15

*

16

* 1. Redistributions of source code must retain the above copyright

16

* 1. Redistributions of source code must retain the above copyright

17

* notice, this list of conditions and the following disclaimer.

17

* notice, this list of conditions and the following disclaimer.

18

* 2. Redistributions in binary form must reproduce the above copyright

18

* 2. Redistributions in binary form must reproduce the above copyright

19

* notice, this list of conditions and the following disclaimer in the

19

* notice, this list of conditions and the following disclaimer in the

20

* documentation and/or other materials provided with the distribution.

20

* documentation and/or other materials provided with the distribution.

21

* 3. Neither the name of the University nor the names of its

21

* 3. Neither the name of the University nor the names of its

22

* contributors may be used to endorse or promote products derived

22

* contributors may be used to endorse or promote products derived

23

* from this software without specific prior written permission.

23

* from this software without specific prior written permission.

24

*

24

*

25

* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

25

* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

26

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

26

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

27

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

27

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

28

* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

28

* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

29

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

29

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

30

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

30

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

31

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

31

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

32

* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

32

* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

33

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

33

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

34

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

34

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

35

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

35

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

36

*/

36

*/

37

38

#include <linux/mm.h>

38

#include <linux/mm.h>

39

#include <linux/delay.h>

39

#include <linux/delay.h>

40

#include <linux/errno.h>

40

#include <linux/errno.h>

41

#include <linux/string.h>

41

#include <linux/string.h>

42

#include <linux/slab.h>

42

#include <linux/slab.h>

43

#include <linux/sunrpc/clnt.h>

43

#include <linux/sunrpc/clnt.h>

44

#include <linux/sunrpc/gss_api.h>

44

#include <linux/sunrpc/gss_api.h>

45

#include <linux/nfs.h>

45

#include <linux/nfs.h>

46

#include <linux/nfs4.h>

46

#include <linux/nfs4.h>

47

#include <linux/nfs_fs.h>

47

#include <linux/nfs_fs.h>

48

#include <linux/nfs_page.h>

48

#include <linux/nfs_page.h>

49

#include <linux/nfs_mount.h>

49

#include <linux/nfs_mount.h>

50

#include <linux/namei.h>

50

#include <linux/namei.h>

51

#include <linux/mount.h>

51

#include <linux/mount.h>

52

#include <linux/module.h>

52

#include <linux/module.h>

53

#include <linux/sunrpc/bc_xprt.h>

53

#include <linux/sunrpc/bc_xprt.h>

54

#include <linux/xattr.h>

54

#include <linux/xattr.h>

55

#include <linux/utsname.h>

55

#include <linux/utsname.h>

56

57

#include "nfs4_fs.h"

57

#include "nfs4_fs.h"

58

#include "delegation.h"

58

#include "delegation.h"

59

#include "internal.h"

59

#include "internal.h"

60

#include "iostat.h"

60

#include "iostat.h"

61

#include "callback.h"

61

#include "callback.h"

62

#include "pnfs.h"

62

#include "pnfs.h"

63

64

#define NFSDBG_FACILITY NFSDBG_PROC

64

#define NFSDBG_FACILITY NFSDBG_PROC

65

66

#define NFS4_POLL_RETRY_MIN (HZ/10)

66

#define NFS4_POLL_RETRY_MIN (HZ/10)

67

#define NFS4_POLL_RETRY_MAX (15*HZ)

67

#define NFS4_POLL_RETRY_MAX (15*HZ)

68

69

#define NFS4_MAX_LOOP_ON_RECOVER (10)

69

#define NFS4_MAX_LOOP_ON_RECOVER (10)

70

71

struct nfs4_opendata;

71

struct nfs4_opendata;

72

static int _nfs4_proc_open(struct nfs4_opendata *data);

72

static int _nfs4_proc_open(struct nfs4_opendata *data);

73

static int _nfs4_recover_proc_open(struct nfs4_opendata *data);

73

static int _nfs4_recover_proc_open(struct nfs4_opendata *data);

74

static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);

74

static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);

75

static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);

75

static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);

76

static int _nfs4_proc_lookup(struct rpc_clnt *client, struct inode *dir,

76

static int _nfs4_proc_lookup(struct rpc_clnt *client, struct inode *dir,

77

const struct qstr *name, struct nfs_fh *fhandle,

77

const struct qstr *name, struct nfs_fh *fhandle,

78

struct nfs_fattr *fattr);

78

struct nfs_fattr *fattr);

79

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);

79

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);

80

static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

80

static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

81

struct nfs_fattr *fattr, struct iattr *sattr,

81

struct nfs_fattr *fattr, struct iattr *sattr,

82

struct nfs4_state *state);

82

struct nfs4_state *state);

83

#ifdef CONFIG_NFS_V4_1

84

static int nfs41_test_stateid(struct nfs_server *, struct nfs4_state *);

85

static int nfs41_free_stateid(struct nfs_server *, struct nfs4_state *);

86

#endif

84

/* Prevent leaks of NFSv4 errors into userland */

87

/* Prevent leaks of NFSv4 errors into userland */

85

static int nfs4_map_errors(int err)

88

static int nfs4_map_errors(int err)

86

{

89

{

87

if (err >= -1000)

90

if (err >= -1000)

88

return err;

91

return err;

89

switch (err) {

92

switch (err) {

90

case -NFS4ERR_RESOURCE:

93

case -NFS4ERR_RESOURCE:

91

return -EREMOTEIO;

94

return -EREMOTEIO;

92

case -NFS4ERR_WRONGSEC:

95

case -NFS4ERR_WRONGSEC:

93

return -EPERM;

96

return -EPERM;

94

case -NFS4ERR_BADOWNER:

97

case -NFS4ERR_BADOWNER:

95

case -NFS4ERR_BADNAME:

98

case -NFS4ERR_BADNAME:

96

return -EINVAL;

99

return -EINVAL;

97

default:

100

default:

98

dprintk("%s could not handle NFSv4 error %d\n",

101

dprintk("%s could not handle NFSv4 error %d\n",

99

__func__, -err);

102

__func__, -err);

100

break;

103

break;

101

}

104

}

102

return -EIO;

105

return -EIO;

103

}

106

}

104

107

105

/*

108

/*

106

* This is our standard bitmap for GETATTR requests.

109

* This is our standard bitmap for GETATTR requests.

107

*/

110

*/

108

const u32 nfs4_fattr_bitmap[2] = {

111

const u32 nfs4_fattr_bitmap[2] = {

109

FATTR4_WORD0_TYPE

112

FATTR4_WORD0_TYPE

110

| FATTR4_WORD0_CHANGE

113

| FATTR4_WORD0_CHANGE

111

| FATTR4_WORD0_SIZE

114

| FATTR4_WORD0_SIZE

112

| FATTR4_WORD0_FSID

115

| FATTR4_WORD0_FSID

113

| FATTR4_WORD0_FILEID,

116

| FATTR4_WORD0_FILEID,

114

FATTR4_WORD1_MODE

117

FATTR4_WORD1_MODE

115

| FATTR4_WORD1_NUMLINKS

118

| FATTR4_WORD1_NUMLINKS

116

| FATTR4_WORD1_OWNER

119

| FATTR4_WORD1_OWNER

117

| FATTR4_WORD1_OWNER_GROUP

120

| FATTR4_WORD1_OWNER_GROUP

118

| FATTR4_WORD1_RAWDEV

121

| FATTR4_WORD1_RAWDEV

119

| FATTR4_WORD1_SPACE_USED

122

| FATTR4_WORD1_SPACE_USED

120

| FATTR4_WORD1_TIME_ACCESS

123

| FATTR4_WORD1_TIME_ACCESS

121

| FATTR4_WORD1_TIME_METADATA

124

| FATTR4_WORD1_TIME_METADATA

122

| FATTR4_WORD1_TIME_MODIFY

125

| FATTR4_WORD1_TIME_MODIFY

123

};

126

};

124

127

125

const u32 nfs4_statfs_bitmap[2] = {

128

const u32 nfs4_statfs_bitmap[2] = {

126

FATTR4_WORD0_FILES_AVAIL

129

FATTR4_WORD0_FILES_AVAIL

127

| FATTR4_WORD0_FILES_FREE

130

| FATTR4_WORD0_FILES_FREE

128

| FATTR4_WORD0_FILES_TOTAL,

131

| FATTR4_WORD0_FILES_TOTAL,

129

FATTR4_WORD1_SPACE_AVAIL

132

FATTR4_WORD1_SPACE_AVAIL

130

| FATTR4_WORD1_SPACE_FREE

133

| FATTR4_WORD1_SPACE_FREE

131

| FATTR4_WORD1_SPACE_TOTAL

134

| FATTR4_WORD1_SPACE_TOTAL

132

};

135

};

133

136

134

const u32 nfs4_pathconf_bitmap[2] = {

137

const u32 nfs4_pathconf_bitmap[2] = {

135

FATTR4_WORD0_MAXLINK

138

FATTR4_WORD0_MAXLINK

136

| FATTR4_WORD0_MAXNAME,

139

| FATTR4_WORD0_MAXNAME,

137

0

140

0

138

};

141

};

139

142

140

const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE

143

const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE

141

| FATTR4_WORD0_MAXREAD

144

| FATTR4_WORD0_MAXREAD

142

| FATTR4_WORD0_MAXWRITE

145

| FATTR4_WORD0_MAXWRITE

143

| FATTR4_WORD0_LEASE_TIME,

146

| FATTR4_WORD0_LEASE_TIME,

144

FATTR4_WORD1_TIME_DELTA

147

FATTR4_WORD1_TIME_DELTA

145

| FATTR4_WORD1_FS_LAYOUT_TYPES

148

| FATTR4_WORD1_FS_LAYOUT_TYPES

146

};

149

};

147

150

148

const u32 nfs4_fs_locations_bitmap[2] = {

151

const u32 nfs4_fs_locations_bitmap[2] = {

149

FATTR4_WORD0_TYPE

152

FATTR4_WORD0_TYPE

150

| FATTR4_WORD0_CHANGE

153

| FATTR4_WORD0_CHANGE

151

| FATTR4_WORD0_SIZE

154

| FATTR4_WORD0_SIZE

152

| FATTR4_WORD0_FSID

155

| FATTR4_WORD0_FSID

153

| FATTR4_WORD0_FILEID

156

| FATTR4_WORD0_FILEID

154

| FATTR4_WORD0_FS_LOCATIONS,

157

| FATTR4_WORD0_FS_LOCATIONS,

155

FATTR4_WORD1_MODE

158

FATTR4_WORD1_MODE

156

| FATTR4_WORD1_NUMLINKS

159

| FATTR4_WORD1_NUMLINKS

157

| FATTR4_WORD1_OWNER

160

| FATTR4_WORD1_OWNER

158

| FATTR4_WORD1_OWNER_GROUP

161

| FATTR4_WORD1_OWNER_GROUP

159

| FATTR4_WORD1_RAWDEV

162

| FATTR4_WORD1_RAWDEV

160

| FATTR4_WORD1_SPACE_USED

163

| FATTR4_WORD1_SPACE_USED

161

| FATTR4_WORD1_TIME_ACCESS

164

| FATTR4_WORD1_TIME_ACCESS

162

| FATTR4_WORD1_TIME_METADATA

165

| FATTR4_WORD1_TIME_METADATA

163

| FATTR4_WORD1_TIME_MODIFY

166

| FATTR4_WORD1_TIME_MODIFY

164

| FATTR4_WORD1_MOUNTED_ON_FILEID

167

| FATTR4_WORD1_MOUNTED_ON_FILEID

165

};

168

};

166

169

167

static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,

170

static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,

168

struct nfs4_readdir_arg *readdir)

171

struct nfs4_readdir_arg *readdir)

169

{

172

{

170

__be32 *start, *p;

173

__be32 *start, *p;

171

174

172

BUG_ON(readdir->count < 80);

175

BUG_ON(readdir->count < 80);

173

if (cookie > 2) {

176

if (cookie > 2) {

174

readdir->cookie = cookie;

177

readdir->cookie = cookie;

175

memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));

178

memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));

176

return;

179

return;

177

}

180

}

178

181

179

readdir->cookie = 0;

182

readdir->cookie = 0;

180

memset(&readdir->verifier, 0, sizeof(readdir->verifier));

183

memset(&readdir->verifier, 0, sizeof(readdir->verifier));

181

if (cookie == 2)

184

if (cookie == 2)

182

return;

185

return;

183

186

184

/*

187

/*

185

* NFSv4 servers do not return entries for '.' and '..'

188

* NFSv4 servers do not return entries for '.' and '..'

186

* Therefore, we fake these entries here. We let '.'

189

* Therefore, we fake these entries here. We let '.'

187

* have cookie 0 and '..' have cookie 1. Note that

190

* have cookie 0 and '..' have cookie 1. Note that

188

* when talking to the server, we always send cookie 0

191

* when talking to the server, we always send cookie 0

189

* instead of 1 or 2.

192

* instead of 1 or 2.

190

*/

193

*/

191

start = p = kmap_atomic(*readdir->pages, KM_USER0);

194

start = p = kmap_atomic(*readdir->pages, KM_USER0);

192

195

193

if (cookie == 0) {

196

if (cookie == 0) {

194

*p++ = xdr_one; /* next */

197

*p++ = xdr_one; /* next */

195

*p++ = xdr_zero; /* cookie, first word */

198

*p++ = xdr_zero; /* cookie, first word */

196

*p++ = xdr_one; /* cookie, second word */

199

*p++ = xdr_one; /* cookie, second word */

197

*p++ = xdr_one; /* entry len */

200

*p++ = xdr_one; /* entry len */

198

memcpy(p, ".\0\0\0", 4); /* entry */

201

memcpy(p, ".\0\0\0", 4); /* entry */

199

p++;

202

p++;

200

*p++ = xdr_one; /* bitmap length */

203

*p++ = xdr_one; /* bitmap length */

201

*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */

204

*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */

202

*p++ = htonl(8); /* attribute buffer length */

205

*p++ = htonl(8); /* attribute buffer length */

203

p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));

206

p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));

204

}

207

}

205

208

206

*p++ = xdr_one; /* next */

209

*p++ = xdr_one; /* next */

207

*p++ = xdr_zero; /* cookie, first word */

210

*p++ = xdr_zero; /* cookie, first word */

208

*p++ = xdr_two; /* cookie, second word */

211

*p++ = xdr_two; /* cookie, second word */

209

*p++ = xdr_two; /* entry len */

212

*p++ = xdr_two; /* entry len */

210

memcpy(p, "..\0\0", 4); /* entry */

213

memcpy(p, "..\0\0", 4); /* entry */

211

p++;

214

p++;

212

*p++ = xdr_one; /* bitmap length */

215

*p++ = xdr_one; /* bitmap length */

213

*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */

216

*p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */

214

*p++ = htonl(8); /* attribute buffer length */

217

*p++ = htonl(8); /* attribute buffer length */

215

p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));

218

p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));

216

219

217

readdir->pgbase = (char *)p - (char *)start;

220

readdir->pgbase = (char *)p - (char *)start;

218

readdir->count -= readdir->pgbase;

221

readdir->count -= readdir->pgbase;

219

kunmap_atomic(start, KM_USER0);

222

kunmap_atomic(start, KM_USER0);

220

}

223

}

221

224

222

static int nfs4_wait_clnt_recover(struct nfs_client *clp)

225

static int nfs4_wait_clnt_recover(struct nfs_client *clp)

223

{

226

{

224

int res;

227

int res;

225

228

226

might_sleep();

229

might_sleep();

227

230

228

res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,

231

res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,

229

nfs_wait_bit_killable, TASK_KILLABLE);

232

nfs_wait_bit_killable, TASK_KILLABLE);

230

return res;

233

return res;

231

}

234

}

232

235

233

static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)

236

static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)

234

{

237

{

235

int res = 0;

238

int res = 0;

236

239

237

might_sleep();

240

might_sleep();

238

241

239

if (*timeout <= 0)

242

if (*timeout <= 0)

240

*timeout = NFS4_POLL_RETRY_MIN;

243

*timeout = NFS4_POLL_RETRY_MIN;

241

if (*timeout > NFS4_POLL_RETRY_MAX)

244

if (*timeout > NFS4_POLL_RETRY_MAX)

242

*timeout = NFS4_POLL_RETRY_MAX;

245

*timeout = NFS4_POLL_RETRY_MAX;

243

schedule_timeout_killable(*timeout);

246

schedule_timeout_killable(*timeout);

244

if (fatal_signal_pending(current))

247

if (fatal_signal_pending(current))

245

res = -ERESTARTSYS;

248

res = -ERESTARTSYS;

246

*timeout <<= 1;

249

*timeout <<= 1;

247

return res;

250

return res;

248

}

251

}

249

252

250

/* This is the error handling routine for processes that are allowed

253

/* This is the error handling routine for processes that are allowed

251

* to sleep.

254

* to sleep.

252

*/

255

*/

253

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

256

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

254

{

257

{

255

struct nfs_client *clp = server->nfs_client;

258

struct nfs_client *clp = server->nfs_client;

256

struct nfs4_state *state = exception->state;

259

struct nfs4_state *state = exception->state;

257

int ret = errorcode;

260

int ret = errorcode;

258

261

259

exception->retry = 0;

262

exception->retry = 0;

260

switch(errorcode) {

263

switch(errorcode) {

261

case 0:

264

case 0:

262

return 0;

265

return 0;

263

case -NFS4ERR_ADMIN_REVOKED:

266

case -NFS4ERR_ADMIN_REVOKED:

264

case -NFS4ERR_BAD_STATEID:

267

case -NFS4ERR_BAD_STATEID:

265

case -NFS4ERR_OPENMODE:

268

case -NFS4ERR_OPENMODE:

266

if (state == NULL)

269

if (state == NULL)

267

break;

270

break;

268

nfs4_schedule_stateid_recovery(server, state);

271

nfs4_schedule_stateid_recovery(server, state);

269

goto wait_on_recovery;

272

goto wait_on_recovery;

270

case -NFS4ERR_EXPIRED:

273

case -NFS4ERR_EXPIRED:

271

if (state != NULL)

274

if (state != NULL)

272

nfs4_schedule_stateid_recovery(server, state);

275

nfs4_schedule_stateid_recovery(server, state);

273

case -NFS4ERR_STALE_STATEID:

276

case -NFS4ERR_STALE_STATEID:

274

case -NFS4ERR_STALE_CLIENTID:

277

case -NFS4ERR_STALE_CLIENTID:

275

nfs4_schedule_lease_recovery(clp);

278

nfs4_schedule_lease_recovery(clp);

276

goto wait_on_recovery;

279

goto wait_on_recovery;

277

#if defined(CONFIG_NFS_V4_1)

280

#if defined(CONFIG_NFS_V4_1)

278

case -NFS4ERR_BADSESSION:

281

case -NFS4ERR_BADSESSION:

279

case -NFS4ERR_BADSLOT:

282

case -NFS4ERR_BADSLOT:

280

case -NFS4ERR_BAD_HIGH_SLOT:

283

case -NFS4ERR_BAD_HIGH_SLOT:

281

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

284

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

282

case -NFS4ERR_DEADSESSION:

285

case -NFS4ERR_DEADSESSION:

283

case -NFS4ERR_SEQ_FALSE_RETRY:

286

case -NFS4ERR_SEQ_FALSE_RETRY:

284

case -NFS4ERR_SEQ_MISORDERED:

287

case -NFS4ERR_SEQ_MISORDERED:

285

dprintk("%s ERROR: %d Reset session\n", __func__,

288

dprintk("%s ERROR: %d Reset session\n", __func__,

286

errorcode);

289

errorcode);

287

nfs4_schedule_session_recovery(clp->cl_session);

290

nfs4_schedule_session_recovery(clp->cl_session);

288

exception->retry = 1;

291

exception->retry = 1;

289

break;

292

break;

290

#endif /* defined(CONFIG_NFS_V4_1) */

293

#endif /* defined(CONFIG_NFS_V4_1) */

291

case -NFS4ERR_FILE_OPEN:

294

case -NFS4ERR_FILE_OPEN:

292

if (exception->timeout > HZ) {

295

if (exception->timeout > HZ) {

293

/* We have retried a decent amount, time to

296

/* We have retried a decent amount, time to

294

* fail

297

* fail

295

*/

298

*/

296

ret = -EBUSY;

299

ret = -EBUSY;

297

break;

300

break;

298

}

301

}

299

case -NFS4ERR_GRACE:

302

case -NFS4ERR_GRACE:

300

case -NFS4ERR_DELAY:

303

case -NFS4ERR_DELAY:

301

case -EKEYEXPIRED:

304

case -EKEYEXPIRED:

302

ret = nfs4_delay(server->client, &exception->timeout);

305

ret = nfs4_delay(server->client, &exception->timeout);

303

if (ret != 0)

306

if (ret != 0)

304

break;

307

break;

305

case -NFS4ERR_RETRY_UNCACHED_REP:

308

case -NFS4ERR_RETRY_UNCACHED_REP:

306

case -NFS4ERR_OLD_STATEID:

309

case -NFS4ERR_OLD_STATEID:

307

exception->retry = 1;

310

exception->retry = 1;

308

break;

311

break;

309

case -NFS4ERR_BADOWNER:

312

case -NFS4ERR_BADOWNER:

310

/* The following works around a Linux server bug! */

313

/* The following works around a Linux server bug! */

311

case -NFS4ERR_BADNAME:

314

case -NFS4ERR_BADNAME:

312

if (server->caps & NFS_CAP_UIDGID_NOMAP) {

315

if (server->caps & NFS_CAP_UIDGID_NOMAP) {

313

server->caps &= ~NFS_CAP_UIDGID_NOMAP;

316

server->caps &= ~NFS_CAP_UIDGID_NOMAP;

314

exception->retry = 1;

317

exception->retry = 1;

315

printk(KERN_WARNING "NFS: v4 server %s "

318

printk(KERN_WARNING "NFS: v4 server %s "

316

"does not accept raw "

319

"does not accept raw "

317

"uid/gids. "

320

"uid/gids. "

318

"Reenabling the idmapper.\n",

321

"Reenabling the idmapper.\n",

319

server->nfs_client->cl_hostname);

322

server->nfs_client->cl_hostname);

320

}

323

}

321

}

324

}

322

/* We failed to handle the error */

325

/* We failed to handle the error */

323

return nfs4_map_errors(ret);

326

return nfs4_map_errors(ret);

324

wait_on_recovery:

327

wait_on_recovery:

325

ret = nfs4_wait_clnt_recover(clp);

328

ret = nfs4_wait_clnt_recover(clp);

326

if (ret == 0)

329

if (ret == 0)

327

exception->retry = 1;

330

exception->retry = 1;

328

return ret;

331

return ret;

329

}

332

}

330

333

331

334

332

static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)

335

static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)

333

{

336

{

334

spin_lock(&clp->cl_lock);

337

spin_lock(&clp->cl_lock);

335

if (time_before(clp->cl_last_renewal,timestamp))

338

if (time_before(clp->cl_last_renewal,timestamp))

336

clp->cl_last_renewal = timestamp;

339

clp->cl_last_renewal = timestamp;

337

spin_unlock(&clp->cl_lock);

340

spin_unlock(&clp->cl_lock);

338

}

341

}

339

342

340

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

343

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

341

{

344

{

342

do_renew_lease(server->nfs_client, timestamp);

345

do_renew_lease(server->nfs_client, timestamp);

343

}

346

}

344

347

345

#if defined(CONFIG_NFS_V4_1)

348

#if defined(CONFIG_NFS_V4_1)

346

349

347

/*

350

/*

348

* nfs4_free_slot - free a slot and efficiently update slot table.

351

* nfs4_free_slot - free a slot and efficiently update slot table.

349

*

352

*

350

* freeing a slot is trivially done by clearing its respective bit

353

* freeing a slot is trivially done by clearing its respective bit

351

* in the bitmap.

354

* in the bitmap.

352

* If the freed slotid equals highest_used_slotid we want to update it

355

* If the freed slotid equals highest_used_slotid we want to update it

353

* so that the server would be able to size down the slot table if needed,

356

* so that the server would be able to size down the slot table if needed,

354

* otherwise we know that the highest_used_slotid is still in use.

357

* otherwise we know that the highest_used_slotid is still in use.

355

* When updating highest_used_slotid there may be "holes" in the bitmap

358

* When updating highest_used_slotid there may be "holes" in the bitmap

356

* so we need to scan down from highest_used_slotid to 0 looking for the now

359

* so we need to scan down from highest_used_slotid to 0 looking for the now

357

* highest slotid in use.

360

* highest slotid in use.

358

* If none found, highest_used_slotid is set to -1.

361

* If none found, highest_used_slotid is set to -1.

359

*

362

*

360

* Must be called while holding tbl->slot_tbl_lock

363

* Must be called while holding tbl->slot_tbl_lock

361

*/

364

*/

362

static void

365

static void

363

nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *free_slot)

366

nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *free_slot)

364

{

367

{

365

int free_slotid = free_slot - tbl->slots;

368

int free_slotid = free_slot - tbl->slots;

366

int slotid = free_slotid;

369

int slotid = free_slotid;

367

370

368

BUG_ON(slotid < 0 || slotid >= NFS4_MAX_SLOT_TABLE);

371

BUG_ON(slotid < 0 || slotid >= NFS4_MAX_SLOT_TABLE);

369

/* clear used bit in bitmap */

372

/* clear used bit in bitmap */

370

__clear_bit(slotid, tbl->used_slots);

373

__clear_bit(slotid, tbl->used_slots);

371

374

372

/* update highest_used_slotid when it is freed */

375

/* update highest_used_slotid when it is freed */

373

if (slotid == tbl->highest_used_slotid) {

376

if (slotid == tbl->highest_used_slotid) {

374

slotid = find_last_bit(tbl->used_slots, tbl->max_slots);

377

slotid = find_last_bit(tbl->used_slots, tbl->max_slots);

375

if (slotid < tbl->max_slots)

378

if (slotid < tbl->max_slots)

376

tbl->highest_used_slotid = slotid;

379

tbl->highest_used_slotid = slotid;

377

else

380

else

378

tbl->highest_used_slotid = -1;

381

tbl->highest_used_slotid = -1;

379

}

382

}

380

dprintk("%s: free_slotid %u highest_used_slotid %d\n", __func__,

383

dprintk("%s: free_slotid %u highest_used_slotid %d\n", __func__,

381

free_slotid, tbl->highest_used_slotid);

384

free_slotid, tbl->highest_used_slotid);

382

}

385

}

383

386

384

/*

387

/*

385

* Signal state manager thread if session fore channel is drained

388

* Signal state manager thread if session fore channel is drained

386

*/

389

*/

387

static void nfs4_check_drain_fc_complete(struct nfs4_session *ses)

390

static void nfs4_check_drain_fc_complete(struct nfs4_session *ses)

388

{

391

{

389

struct rpc_task *task;

392

struct rpc_task *task;

390

393

391

if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {

394

if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state)) {

392

task = rpc_wake_up_next(&ses->fc_slot_table.slot_tbl_waitq);

395

task = rpc_wake_up_next(&ses->fc_slot_table.slot_tbl_waitq);

393

if (task)

396

if (task)

394

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

397

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

395

return;

398

return;

396

}

399

}

397

400

398

if (ses->fc_slot_table.highest_used_slotid != -1)

401

if (ses->fc_slot_table.highest_used_slotid != -1)

399

return;

402

return;

400

403

401

dprintk("%s COMPLETE: Session Fore Channel Drained\n", __func__);

404

dprintk("%s COMPLETE: Session Fore Channel Drained\n", __func__);

402

complete(&ses->fc_slot_table.complete);

405

complete(&ses->fc_slot_table.complete);

403

}

406

}

404

407

405

/*

408

/*

406

* Signal state manager thread if session back channel is drained

409

* Signal state manager thread if session back channel is drained

407

*/

410

*/

408

void nfs4_check_drain_bc_complete(struct nfs4_session *ses)

411

void nfs4_check_drain_bc_complete(struct nfs4_session *ses)

409

{

412

{

410

if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state) ||

413

if (!test_bit(NFS4_SESSION_DRAINING, &ses->session_state) ||

411

ses->bc_slot_table.highest_used_slotid != -1)

414

ses->bc_slot_table.highest_used_slotid != -1)

412

return;

415

return;

413

dprintk("%s COMPLETE: Session Back Channel Drained\n", __func__);

416

dprintk("%s COMPLETE: Session Back Channel Drained\n", __func__);

414

complete(&ses->bc_slot_table.complete);

417

complete(&ses->bc_slot_table.complete);

415

}

418

}

416

419

417

static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)

420

static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)

418

{

421

{

419

struct nfs4_slot_table *tbl;

422

struct nfs4_slot_table *tbl;

420

423

421

tbl = &res->sr_session->fc_slot_table;

424

tbl = &res->sr_session->fc_slot_table;

422

if (!res->sr_slot) {

425

if (!res->sr_slot) {

423

/* just wake up the next guy waiting since

426

/* just wake up the next guy waiting since

424

* we may have not consumed a slot after all */

427

* we may have not consumed a slot after all */

425

dprintk("%s: No slot\n", __func__);

428

dprintk("%s: No slot\n", __func__);

426

return;

429

return;

427

}

430

}

428

431

429

spin_lock(&tbl->slot_tbl_lock);

432

spin_lock(&tbl->slot_tbl_lock);

430

nfs4_free_slot(tbl, res->sr_slot);

433

nfs4_free_slot(tbl, res->sr_slot);

431

nfs4_check_drain_fc_complete(res->sr_session);

434

nfs4_check_drain_fc_complete(res->sr_session);

432

spin_unlock(&tbl->slot_tbl_lock);

435

spin_unlock(&tbl->slot_tbl_lock);

433

res->sr_slot = NULL;

436

res->sr_slot = NULL;

434

}

437

}

435

438

436

static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)

439

static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)

437

{

440

{

438

unsigned long timestamp;

441

unsigned long timestamp;

439

struct nfs_client *clp;

442

struct nfs_client *clp;

440

443

441

/*

444

/*

442

* sr_status remains 1 if an RPC level error occurred. The server

445

* sr_status remains 1 if an RPC level error occurred. The server

443

* may or may not have processed the sequence operation..

446

* may or may not have processed the sequence operation..

444

* Proceed as if the server received and processed the sequence

447

* Proceed as if the server received and processed the sequence

445

* operation.

448

* operation.

446

*/

449

*/

447

if (res->sr_status == 1)

450

if (res->sr_status == 1)

448

res->sr_status = NFS_OK;

451

res->sr_status = NFS_OK;

449

452

450

/* don't increment the sequence number if the task wasn't sent */

453

/* don't increment the sequence number if the task wasn't sent */

451

if (!RPC_WAS_SENT(task))

454

if (!RPC_WAS_SENT(task))

452

goto out;

455

goto out;

453

456

454

/* Check the SEQUENCE operation status */

457

/* Check the SEQUENCE operation status */

455

switch (res->sr_status) {

458

switch (res->sr_status) {

456

case 0:

459

case 0:

457

/* Update the slot's sequence and clientid lease timer */

460

/* Update the slot's sequence and clientid lease timer */

458

++res->sr_slot->seq_nr;

461

++res->sr_slot->seq_nr;

459

timestamp = res->sr_renewal_time;

462

timestamp = res->sr_renewal_time;

460

clp = res->sr_session->clp;

463

clp = res->sr_session->clp;

461

do_renew_lease(clp, timestamp);

464

do_renew_lease(clp, timestamp);

462

/* Check sequence flags */

465

/* Check sequence flags */

463

if (res->sr_status_flags != 0)

466

if (res->sr_status_flags != 0)

464

nfs4_schedule_lease_recovery(clp);

467

nfs4_schedule_lease_recovery(clp);

465

break;

468

break;

466

case -NFS4ERR_DELAY:

469

case -NFS4ERR_DELAY:

467

/* The server detected a resend of the RPC call and

470

/* The server detected a resend of the RPC call and

468

* returned NFS4ERR_DELAY as per Section 2.10.6.2

471

* returned NFS4ERR_DELAY as per Section 2.10.6.2

469

* of RFC5661.

472

* of RFC5661.

470

*/

473

*/

471

dprintk("%s: slot=%td seq=%d: Operation in progress\n",

474

dprintk("%s: slot=%td seq=%d: Operation in progress\n",

472

__func__,

475

__func__,

473

res->sr_slot - res->sr_session->fc_slot_table.slots,

476

res->sr_slot - res->sr_session->fc_slot_table.slots,

474

res->sr_slot->seq_nr);

477

res->sr_slot->seq_nr);

475

goto out_retry;

478

goto out_retry;

476

default:

479

default:

477

/* Just update the slot sequence no. */

480

/* Just update the slot sequence no. */

478

++res->sr_slot->seq_nr;

481

++res->sr_slot->seq_nr;

479

}

482

}

480

out:

483

out:

481

/* The session may be reset by one of the error handlers. */

484

/* The session may be reset by one of the error handlers. */

482

dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);

485

dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);

483

nfs41_sequence_free_slot(res);

486

nfs41_sequence_free_slot(res);

484

return 1;

487

return 1;

485

out_retry:

488

out_retry:

486

if (!rpc_restart_call(task))

489

if (!rpc_restart_call(task))

487

goto out;

490

goto out;

488

rpc_delay(task, NFS4_POLL_RETRY_MAX);

491

rpc_delay(task, NFS4_POLL_RETRY_MAX);

489

return 0;

492

return 0;

490

}

493

}

491

494

492

static int nfs4_sequence_done(struct rpc_task *task,

495

static int nfs4_sequence_done(struct rpc_task *task,

493

struct nfs4_sequence_res *res)

496

struct nfs4_sequence_res *res)

494

{

497

{

495

if (res->sr_session == NULL)

498

if (res->sr_session == NULL)

496

return 1;

499

return 1;

497

return nfs41_sequence_done(task, res);

500

return nfs41_sequence_done(task, res);

498

}

501

}

499

502

500

/*

503

/*

501

* nfs4_find_slot - efficiently look for a free slot

504

* nfs4_find_slot - efficiently look for a free slot

502

*

505

*

503

* nfs4_find_slot looks for an unset bit in the used_slots bitmap.

506

* nfs4_find_slot looks for an unset bit in the used_slots bitmap.

504

* If found, we mark the slot as used, update the highest_used_slotid,

507

* If found, we mark the slot as used, update the highest_used_slotid,

505

* and respectively set up the sequence operation args.

508

* and respectively set up the sequence operation args.

506

* The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise.

509

* The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise.

507

*

510

*

508

* Note: must be called with under the slot_tbl_lock.

511

* Note: must be called with under the slot_tbl_lock.

509

*/

512

*/

510

static u8

513

static u8

511

nfs4_find_slot(struct nfs4_slot_table *tbl)

514

nfs4_find_slot(struct nfs4_slot_table *tbl)

512

{

515

{

513

int slotid;

516

int slotid;

514

u8 ret_id = NFS4_MAX_SLOT_TABLE;

517

u8 ret_id = NFS4_MAX_SLOT_TABLE;

515

BUILD_BUG_ON((u8)NFS4_MAX_SLOT_TABLE != (int)NFS4_MAX_SLOT_TABLE);

518

BUILD_BUG_ON((u8)NFS4_MAX_SLOT_TABLE != (int)NFS4_MAX_SLOT_TABLE);

516

519

517

dprintk("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n",

520

dprintk("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n",

518

__func__, tbl->used_slots[0], tbl->highest_used_slotid,

521

__func__, tbl->used_slots[0], tbl->highest_used_slotid,

519

tbl->max_slots);

522

tbl->max_slots);

520

slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slots);

523

slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slots);

521

if (slotid >= tbl->max_slots)

524

if (slotid >= tbl->max_slots)

522

goto out;

525

goto out;

523

__set_bit(slotid, tbl->used_slots);

526

__set_bit(slotid, tbl->used_slots);

524

if (slotid > tbl->highest_used_slotid)

527

if (slotid > tbl->highest_used_slotid)

525

tbl->highest_used_slotid = slotid;

528

tbl->highest_used_slotid = slotid;

526

ret_id = slotid;

529

ret_id = slotid;

527

out:

530

out:

528

dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n",

531

dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n",

529

__func__, tbl->used_slots[0], tbl->highest_used_slotid, ret_id);

532

__func__, tbl->used_slots[0], tbl->highest_used_slotid, ret_id);

530

return ret_id;

533

return ret_id;

531

}

534

}

532

535

533

int nfs41_setup_sequence(struct nfs4_session *session,

536

int nfs41_setup_sequence(struct nfs4_session *session,

534

struct nfs4_sequence_args *args,

537

struct nfs4_sequence_args *args,

535

struct nfs4_sequence_res *res,

538

struct nfs4_sequence_res *res,

536

int cache_reply,

539

int cache_reply,

537

struct rpc_task *task)

540

struct rpc_task *task)

538

{

541

{

539

struct nfs4_slot *slot;

542

struct nfs4_slot *slot;

540

struct nfs4_slot_table *tbl;

543

struct nfs4_slot_table *tbl;

541

u8 slotid;

544

u8 slotid;

542

545

543

dprintk("--> %s\n", __func__);

546

dprintk("--> %s\n", __func__);

544

/* slot already allocated? */

547

/* slot already allocated? */

545

if (res->sr_slot != NULL)

548

if (res->sr_slot != NULL)

546

return 0;

549

return 0;

547

550

548

tbl = &session->fc_slot_table;

551

tbl = &session->fc_slot_table;

549

552

550

spin_lock(&tbl->slot_tbl_lock);

553

spin_lock(&tbl->slot_tbl_lock);

551

if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&

554

if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&

552

!rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {

555

!rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {

553

/*

556

/*

554

* The state manager will wait until the slot table is empty.

557

* The state manager will wait until the slot table is empty.

555

* Schedule the reset thread

558

* Schedule the reset thread

556

*/

559

*/

557

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

560

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

558

spin_unlock(&tbl->slot_tbl_lock);

561

spin_unlock(&tbl->slot_tbl_lock);

559

dprintk("%s Schedule Session Reset\n", __func__);

562

dprintk("%s Schedule Session Reset\n", __func__);

560

return -EAGAIN;

563

return -EAGAIN;

561

}

564

}

562

565

563

if (!rpc_queue_empty(&tbl->slot_tbl_waitq) &&

566

if (!rpc_queue_empty(&tbl->slot_tbl_waitq) &&

564

!rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {

567

!rpc_task_has_priority(task, RPC_PRIORITY_PRIVILEGED)) {

565

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

568

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

566

spin_unlock(&tbl->slot_tbl_lock);

569

spin_unlock(&tbl->slot_tbl_lock);

567

dprintk("%s enforce FIFO order\n", __func__);

570

dprintk("%s enforce FIFO order\n", __func__);

568

return -EAGAIN;

571

return -EAGAIN;

569

}

572

}

570

573

571

slotid = nfs4_find_slot(tbl);

574

slotid = nfs4_find_slot(tbl);

572

if (slotid == NFS4_MAX_SLOT_TABLE) {

575

if (slotid == NFS4_MAX_SLOT_TABLE) {

573

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

576

rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);

574

spin_unlock(&tbl->slot_tbl_lock);

577

spin_unlock(&tbl->slot_tbl_lock);

575

dprintk("<-- %s: no free slots\n", __func__);

578

dprintk("<-- %s: no free slots\n", __func__);

576

return -EAGAIN;

579

return -EAGAIN;

577

}

580

}

578

spin_unlock(&tbl->slot_tbl_lock);

581

spin_unlock(&tbl->slot_tbl_lock);

579

582

580

rpc_task_set_priority(task, RPC_PRIORITY_NORMAL);

583

rpc_task_set_priority(task, RPC_PRIORITY_NORMAL);

581

slot = tbl->slots + slotid;

584

slot = tbl->slots + slotid;

582

args->sa_session = session;

585

args->sa_session = session;

583

args->sa_slotid = slotid;

586

args->sa_slotid = slotid;

584

args->sa_cache_this = cache_reply;

587

args->sa_cache_this = cache_reply;

585

588

586

dprintk("<-- %s slotid=%d seqid=%d\n", __func__, slotid, slot->seq_nr);

589

dprintk("<-- %s slotid=%d seqid=%d\n", __func__, slotid, slot->seq_nr);

587

590

588

res->sr_session = session;

591

res->sr_session = session;

589

res->sr_slot = slot;

592

res->sr_slot = slot;

590

res->sr_renewal_time = jiffies;

593

res->sr_renewal_time = jiffies;

591

res->sr_status_flags = 0;

594

res->sr_status_flags = 0;

592

/*

595

/*

593

* sr_status is only set in decode_sequence, and so will remain

596

* sr_status is only set in decode_sequence, and so will remain

594

* set to 1 if an rpc level failure occurs.

597

* set to 1 if an rpc level failure occurs.

595

*/

598

*/

596

res->sr_status = 1;

599

res->sr_status = 1;

597

return 0;

600

return 0;

598

}

601

}

599

EXPORT_SYMBOL_GPL(nfs41_setup_sequence);

602

EXPORT_SYMBOL_GPL(nfs41_setup_sequence);

600

603

601

int nfs4_setup_sequence(const struct nfs_server *server,

604

int nfs4_setup_sequence(const struct nfs_server *server,

602

struct nfs4_sequence_args *args,

605

struct nfs4_sequence_args *args,

603

struct nfs4_sequence_res *res,

606

struct nfs4_sequence_res *res,

604

int cache_reply,

607

int cache_reply,

605

struct rpc_task *task)

608

struct rpc_task *task)

606

{

609

{

607

struct nfs4_session *session = nfs4_get_session(server);

610

struct nfs4_session *session = nfs4_get_session(server);

608

int ret = 0;

611

int ret = 0;

609

612

610

if (session == NULL) {

613

if (session == NULL) {

611

args->sa_session = NULL;

614

args->sa_session = NULL;

612

res->sr_session = NULL;

615

res->sr_session = NULL;

613

goto out;

616

goto out;

614

}

617

}

615

618

616

dprintk("--> %s clp %p session %p sr_slot %td\n",

619

dprintk("--> %s clp %p session %p sr_slot %td\n",

617

__func__, session->clp, session, res->sr_slot ?

620

__func__, session->clp, session, res->sr_slot ?

618

res->sr_slot - session->fc_slot_table.slots : -1);

621

res->sr_slot - session->fc_slot_table.slots : -1);

619

622

620

ret = nfs41_setup_sequence(session, args, res, cache_reply,

623

ret = nfs41_setup_sequence(session, args, res, cache_reply,

621

task);

624

task);

622

out:

625

out:

623

dprintk("<-- %s status=%d\n", __func__, ret);

626

dprintk("<-- %s status=%d\n", __func__, ret);

624

return ret;

627

return ret;

625

}

628

}

626

629

627

struct nfs41_call_sync_data {

630

struct nfs41_call_sync_data {

628

const struct nfs_server *seq_server;

631

const struct nfs_server *seq_server;

629

struct nfs4_sequence_args *seq_args;

632

struct nfs4_sequence_args *seq_args;

630

struct nfs4_sequence_res *seq_res;

633

struct nfs4_sequence_res *seq_res;

631

int cache_reply;

634

int cache_reply;

632

};

635

};

633

636

634

static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)

637

static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)

635

{

638

{

636

struct nfs41_call_sync_data *data = calldata;

639

struct nfs41_call_sync_data *data = calldata;

637

640

638

dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);

641

dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);

639

642

640

if (nfs4_setup_sequence(data->seq_server, data->seq_args,

643

if (nfs4_setup_sequence(data->seq_server, data->seq_args,

641

data->seq_res, data->cache_reply, task))

644

data->seq_res, data->cache_reply, task))

642

return;

645

return;

643

rpc_call_start(task);

646

rpc_call_start(task);

644

}

647

}

645

648

646

static void nfs41_call_priv_sync_prepare(struct rpc_task *task, void *calldata)

649

static void nfs41_call_priv_sync_prepare(struct rpc_task *task, void *calldata)

647

{

650

{

648

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

651

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

649

nfs41_call_sync_prepare(task, calldata);

652

nfs41_call_sync_prepare(task, calldata);

650

}

653

}

651

654

652

static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)

655

static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)

653

{

656

{

654

struct nfs41_call_sync_data *data = calldata;

657

struct nfs41_call_sync_data *data = calldata;

655

658

656

nfs41_sequence_done(task, data->seq_res);

659

nfs41_sequence_done(task, data->seq_res);

657

}

660

}

658

661

659

struct rpc_call_ops nfs41_call_sync_ops = {

662

struct rpc_call_ops nfs41_call_sync_ops = {

660

.rpc_call_prepare = nfs41_call_sync_prepare,

663

.rpc_call_prepare = nfs41_call_sync_prepare,

661

.rpc_call_done = nfs41_call_sync_done,

664

.rpc_call_done = nfs41_call_sync_done,

662

};

665

};

663

666

664

struct rpc_call_ops nfs41_call_priv_sync_ops = {

667

struct rpc_call_ops nfs41_call_priv_sync_ops = {

665

.rpc_call_prepare = nfs41_call_priv_sync_prepare,

668

.rpc_call_prepare = nfs41_call_priv_sync_prepare,

666

.rpc_call_done = nfs41_call_sync_done,

669

.rpc_call_done = nfs41_call_sync_done,

667

};

670

};

668

671

669

static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,

672

static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,

670

struct nfs_server *server,

673

struct nfs_server *server,

671

struct rpc_message *msg,

674

struct rpc_message *msg,

672

struct nfs4_sequence_args *args,

675

struct nfs4_sequence_args *args,

673

struct nfs4_sequence_res *res,

676

struct nfs4_sequence_res *res,

674

int cache_reply,

677

int cache_reply,

675

int privileged)

678

int privileged)

676

{

679

{

677

int ret;

680

int ret;

678

struct rpc_task *task;

681

struct rpc_task *task;

679

struct nfs41_call_sync_data data = {

682

struct nfs41_call_sync_data data = {

680

.seq_server = server,

683

.seq_server = server,

681

.seq_args = args,

684

.seq_args = args,

682

.seq_res = res,

685

.seq_res = res,

683

.cache_reply = cache_reply,

686

.cache_reply = cache_reply,

684

};

687

};

685

struct rpc_task_setup task_setup = {

688

struct rpc_task_setup task_setup = {

686

.rpc_client = clnt,

689

.rpc_client = clnt,

687

.rpc_message = msg,

690

.rpc_message = msg,

688

.callback_ops = &nfs41_call_sync_ops,

691

.callback_ops = &nfs41_call_sync_ops,

689

.callback_data = &data

692

.callback_data = &data

690

};

693

};

691

694

692

res->sr_slot = NULL;

695

res->sr_slot = NULL;

693

if (privileged)

696

if (privileged)

694

task_setup.callback_ops = &nfs41_call_priv_sync_ops;

697

task_setup.callback_ops = &nfs41_call_priv_sync_ops;

695

task = rpc_run_task(&task_setup);

698

task = rpc_run_task(&task_setup);

696

if (IS_ERR(task))

699

if (IS_ERR(task))

697

ret = PTR_ERR(task);

700

ret = PTR_ERR(task);

698

else {

701

else {

699

ret = task->tk_status;

702

ret = task->tk_status;

700

rpc_put_task(task);

703

rpc_put_task(task);

701

}

704

}

702

return ret;

705

return ret;

703

}

706

}

704

707

705

int _nfs4_call_sync_session(struct rpc_clnt *clnt,

708

int _nfs4_call_sync_session(struct rpc_clnt *clnt,

706

struct nfs_server *server,

709

struct nfs_server *server,

707

struct rpc_message *msg,

710

struct rpc_message *msg,

708

struct nfs4_sequence_args *args,

711

struct nfs4_sequence_args *args,

709

struct nfs4_sequence_res *res,

712

struct nfs4_sequence_res *res,

710

int cache_reply)

713

int cache_reply)

711

{

714

{

712

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

715

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

713

}

716

}

714

717

715

#else

718

#else

716

static int nfs4_sequence_done(struct rpc_task *task,

719

static int nfs4_sequence_done(struct rpc_task *task,

717

struct nfs4_sequence_res *res)

720

struct nfs4_sequence_res *res)

718

{

721

{

719

return 1;

722

return 1;

720

}

723

}

721

#endif /* CONFIG_NFS_V4_1 */

724

#endif /* CONFIG_NFS_V4_1 */

722

725

723

int _nfs4_call_sync(struct rpc_clnt *clnt,

726

int _nfs4_call_sync(struct rpc_clnt *clnt,

724

struct nfs_server *server,

727

struct nfs_server *server,

725

struct rpc_message *msg,

728

struct rpc_message *msg,

726

struct nfs4_sequence_args *args,

729

struct nfs4_sequence_args *args,

727

struct nfs4_sequence_res *res,

730

struct nfs4_sequence_res *res,

728

int cache_reply)

731

int cache_reply)

729

{

732

{

730

args->sa_session = res->sr_session = NULL;

733

args->sa_session = res->sr_session = NULL;

731

return rpc_call_sync(clnt, msg, 0);

734

return rpc_call_sync(clnt, msg, 0);

732

}

735

}

733

736

734

static inline

737

static inline

735

int nfs4_call_sync(struct rpc_clnt *clnt,

738

int nfs4_call_sync(struct rpc_clnt *clnt,

736

struct nfs_server *server,

739

struct nfs_server *server,

737

struct rpc_message *msg,

740

struct rpc_message *msg,

738

struct nfs4_sequence_args *args,

741

struct nfs4_sequence_args *args,

739

struct nfs4_sequence_res *res,

742

struct nfs4_sequence_res *res,

740

int cache_reply)

743

int cache_reply)

741

{

744

{

742

return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,

745

return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,

743

args, res, cache_reply);

746

args, res, cache_reply);

744

}

747

}

745

748

746

static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)

749

static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)

747

{

750

{

748

struct nfs_inode *nfsi = NFS_I(dir);

751

struct nfs_inode *nfsi = NFS_I(dir);

749

752

750

spin_lock(&dir->i_lock);

753

spin_lock(&dir->i_lock);

751

nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;

754

nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;

752

if (!cinfo->atomic || cinfo->before != nfsi->change_attr)

755

if (!cinfo->atomic || cinfo->before != nfsi->change_attr)

753

nfs_force_lookup_revalidate(dir);

756

nfs_force_lookup_revalidate(dir);

754

nfsi->change_attr = cinfo->after;

757

nfsi->change_attr = cinfo->after;

755

spin_unlock(&dir->i_lock);

758

spin_unlock(&dir->i_lock);

756

}

759

}

757

760

758

struct nfs4_opendata {

761

struct nfs4_opendata {

759

struct kref kref;

762

struct kref kref;

760

struct nfs_openargs o_arg;

763

struct nfs_openargs o_arg;

761

struct nfs_openres o_res;

764

struct nfs_openres o_res;

762

struct nfs_open_confirmargs c_arg;

765

struct nfs_open_confirmargs c_arg;

763

struct nfs_open_confirmres c_res;

766

struct nfs_open_confirmres c_res;

764

struct nfs_fattr f_attr;

767

struct nfs_fattr f_attr;

765

struct nfs_fattr dir_attr;

768

struct nfs_fattr dir_attr;

766

struct path path;

769

struct path path;

767

struct dentry *dir;

770

struct dentry *dir;

768

struct nfs4_state_owner *owner;

771

struct nfs4_state_owner *owner;

769

struct nfs4_state *state;

772

struct nfs4_state *state;

770

struct iattr attrs;

773

struct iattr attrs;

771

unsigned long timestamp;

774

unsigned long timestamp;

772

unsigned int rpc_done : 1;

775

unsigned int rpc_done : 1;

773

int rpc_status;

776

int rpc_status;

774

int cancelled;

777

int cancelled;

775

};

778

};

776

779

777

780

778

static void nfs4_init_opendata_res(struct nfs4_opendata *p)

781

static void nfs4_init_opendata_res(struct nfs4_opendata *p)

779

{

782

{

780

p->o_res.f_attr = &p->f_attr;

783

p->o_res.f_attr = &p->f_attr;

781

p->o_res.dir_attr = &p->dir_attr;

784

p->o_res.dir_attr = &p->dir_attr;

782

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

785

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

783

p->c_res.seqid = p->c_arg.seqid;

786

p->c_res.seqid = p->c_arg.seqid;

784

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

787

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

785

nfs_fattr_init(&p->f_attr);

788

nfs_fattr_init(&p->f_attr);

786

nfs_fattr_init(&p->dir_attr);

789

nfs_fattr_init(&p->dir_attr);

787

}

790

}

788

791

789

static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,

792

static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,

790

struct nfs4_state_owner *sp, fmode_t fmode, int flags,

793

struct nfs4_state_owner *sp, fmode_t fmode, int flags,

791

const struct iattr *attrs,

794

const struct iattr *attrs,

792

gfp_t gfp_mask)

795

gfp_t gfp_mask)

793

{

796

{

794

struct dentry *parent = dget_parent(path->dentry);

797

struct dentry *parent = dget_parent(path->dentry);

795

struct inode *dir = parent->d_inode;

798

struct inode *dir = parent->d_inode;

796

struct nfs_server *server = NFS_SERVER(dir);

799

struct nfs_server *server = NFS_SERVER(dir);

797

struct nfs4_opendata *p;

800

struct nfs4_opendata *p;

798

801

799

p = kzalloc(sizeof(*p), gfp_mask);

802

p = kzalloc(sizeof(*p), gfp_mask);

800

if (p == NULL)

803

if (p == NULL)

801

goto err;

804

goto err;

802

p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);

805

p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);

803

if (p->o_arg.seqid == NULL)

806

if (p->o_arg.seqid == NULL)

804

goto err_free;

807

goto err_free;

805

path_get(path);

808

path_get(path);

806

p->path = *path;

809

p->path = *path;

807

p->dir = parent;

810

p->dir = parent;

808

p->owner = sp;

811

p->owner = sp;

809

atomic_inc(&sp->so_count);

812

atomic_inc(&sp->so_count);

810

p->o_arg.fh = NFS_FH(dir);

813

p->o_arg.fh = NFS_FH(dir);

811

p->o_arg.open_flags = flags;

814

p->o_arg.open_flags = flags;

812

p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);

815

p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);

813

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

816

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

814

p->o_arg.id = sp->so_owner_id.id;

817

p->o_arg.id = sp->so_owner_id.id;

815

p->o_arg.name = &p->path.dentry->d_name;

818

p->o_arg.name = &p->path.dentry->d_name;

816

p->o_arg.server = server;

819

p->o_arg.server = server;

817

p->o_arg.bitmask = server->attr_bitmask;

820

p->o_arg.bitmask = server->attr_bitmask;

818

p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;

821

p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;

819

if (flags & O_CREAT) {

822

if (flags & O_CREAT) {

820

u32 *s;

823

u32 *s;

821

824

822

p->o_arg.u.attrs = &p->attrs;

825

p->o_arg.u.attrs = &p->attrs;

823

memcpy(&p->attrs, attrs, sizeof(p->attrs));

826

memcpy(&p->attrs, attrs, sizeof(p->attrs));

824

s = (u32 *) p->o_arg.u.verifier.data;

827

s = (u32 *) p->o_arg.u.verifier.data;

825

s[0] = jiffies;

828

s[0] = jiffies;

826

s[1] = current->pid;

829

s[1] = current->pid;

827

}

830

}

828

p->c_arg.fh = &p->o_res.fh;

831

p->c_arg.fh = &p->o_res.fh;

829

p->c_arg.stateid = &p->o_res.stateid;

832

p->c_arg.stateid = &p->o_res.stateid;

830

p->c_arg.seqid = p->o_arg.seqid;

833

p->c_arg.seqid = p->o_arg.seqid;

831

nfs4_init_opendata_res(p);

834

nfs4_init_opendata_res(p);

832

kref_init(&p->kref);

835

kref_init(&p->kref);

833

return p;

836

return p;

834

err_free:

837

err_free:

835

kfree(p);

838

kfree(p);

836

err:

839

err:

837

dput(parent);

840

dput(parent);

838

return NULL;

841

return NULL;

839

}

842

}

840

843

841

static void nfs4_opendata_free(struct kref *kref)

844

static void nfs4_opendata_free(struct kref *kref)

842

{

845

{

843

struct nfs4_opendata *p = container_of(kref,

846

struct nfs4_opendata *p = container_of(kref,

844

struct nfs4_opendata, kref);

847

struct nfs4_opendata, kref);

845

848

846

nfs_free_seqid(p->o_arg.seqid);

849

nfs_free_seqid(p->o_arg.seqid);

847

if (p->state != NULL)

850

if (p->state != NULL)

848

nfs4_put_open_state(p->state);

851

nfs4_put_open_state(p->state);

849

nfs4_put_state_owner(p->owner);

852

nfs4_put_state_owner(p->owner);

850

dput(p->dir);

853

dput(p->dir);

851

path_put(&p->path);

854

path_put(&p->path);

852

kfree(p);

855

kfree(p);

853

}

856

}

854

857

855

static void nfs4_opendata_put(struct nfs4_opendata *p)

858

static void nfs4_opendata_put(struct nfs4_opendata *p)

856

{

859

{

857

if (p != NULL)

860

if (p != NULL)

858

kref_put(&p->kref, nfs4_opendata_free);

861

kref_put(&p->kref, nfs4_opendata_free);

859

}

862

}

860

863

861

static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)

864

static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)

862

{

865

{

863

int ret;

866

int ret;

864

867

865

ret = rpc_wait_for_completion_task(task);

868

ret = rpc_wait_for_completion_task(task);

866

return ret;

869

return ret;

867

}

870

}

868

871

869

static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)

872

static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)

870

{

873

{

871

int ret = 0;

874

int ret = 0;

872

875

873

if (open_mode & O_EXCL)

876

if (open_mode & O_EXCL)

874

goto out;

877

goto out;

875

switch (mode & (FMODE_READ|FMODE_WRITE)) {

878

switch (mode & (FMODE_READ|FMODE_WRITE)) {

876

case FMODE_READ:

879

case FMODE_READ:

877

ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0

880

ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0

878

&& state->n_rdonly != 0;

881

&& state->n_rdonly != 0;

879

break;

882

break;

880

case FMODE_WRITE:

883

case FMODE_WRITE:

881

ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0

884

ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0

882

&& state->n_wronly != 0;

885

&& state->n_wronly != 0;

883

break;

886

break;

884

case FMODE_READ|FMODE_WRITE:

887

case FMODE_READ|FMODE_WRITE:

885

ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0

888

ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0

886

&& state->n_rdwr != 0;

889

&& state->n_rdwr != 0;

887

}

890

}

888

out:

891

out:

889

return ret;

892

return ret;

890

}

893

}

891

894

892

static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)

895

static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)

893

{

896

{

894

if ((delegation->type & fmode) != fmode)

897

if ((delegation->type & fmode) != fmode)

895

return 0;

898

return 0;

896

if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))

899

if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))

897

return 0;

900

return 0;

898

nfs_mark_delegation_referenced(delegation);

901

nfs_mark_delegation_referenced(delegation);

899

return 1;

902

return 1;

900

}

903

}

901

904

902

static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)

905

static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)

903

{

906

{

904

switch (fmode) {

907

switch (fmode) {

905

case FMODE_WRITE:

908

case FMODE_WRITE:

906

state->n_wronly++;

909

state->n_wronly++;

907

break;

910

break;

908

case FMODE_READ:

911

case FMODE_READ:

909

state->n_rdonly++;

912

state->n_rdonly++;

910

break;

913

break;

911

case FMODE_READ|FMODE_WRITE:

914

case FMODE_READ|FMODE_WRITE:

912

state->n_rdwr++;

915

state->n_rdwr++;

913

}

916

}

914

nfs4_state_set_mode_locked(state, state->state | fmode);

917

nfs4_state_set_mode_locked(state, state->state | fmode);

915

}

918

}

916

919

917

static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)

920

static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)

918

{

921

{

919

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)

922

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)

920

memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));

923

memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));

921

memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));

924

memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));

922

switch (fmode) {

925

switch (fmode) {

923

case FMODE_READ:

926

case FMODE_READ:

924

set_bit(NFS_O_RDONLY_STATE, &state->flags);

927

set_bit(NFS_O_RDONLY_STATE, &state->flags);

925

break;

928

break;

926

case FMODE_WRITE:

929

case FMODE_WRITE:

927

set_bit(NFS_O_WRONLY_STATE, &state->flags);

930

set_bit(NFS_O_WRONLY_STATE, &state->flags);

928

break;

931

break;

929

case FMODE_READ|FMODE_WRITE:

932

case FMODE_READ|FMODE_WRITE:

930

set_bit(NFS_O_RDWR_STATE, &state->flags);

933

set_bit(NFS_O_RDWR_STATE, &state->flags);

931

}

934

}

932

}

935

}

933

936

934

static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)

937

static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)

935

{

938

{

936

write_seqlock(&state->seqlock);

939

write_seqlock(&state->seqlock);

937

nfs_set_open_stateid_locked(state, stateid, fmode);

940

nfs_set_open_stateid_locked(state, stateid, fmode);

938

write_sequnlock(&state->seqlock);

941

write_sequnlock(&state->seqlock);

939

}

942

}

940

943

941

static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)

944

static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)

942

{

945

{

943

/*

946

/*

944

* Protect the call to nfs4_state_set_mode_locked and

947

* Protect the call to nfs4_state_set_mode_locked and

945

* serialise the stateid update

948

* serialise the stateid update

946

*/

949

*/

947

write_seqlock(&state->seqlock);

950

write_seqlock(&state->seqlock);

948

if (deleg_stateid != NULL) {

951

if (deleg_stateid != NULL) {

949

memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));

952

memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));

950

set_bit(NFS_DELEGATED_STATE, &state->flags);

953

set_bit(NFS_DELEGATED_STATE, &state->flags);

951

}

954

}

952

if (open_stateid != NULL)

955

if (open_stateid != NULL)

953

nfs_set_open_stateid_locked(state, open_stateid, fmode);

956

nfs_set_open_stateid_locked(state, open_stateid, fmode);

954

write_sequnlock(&state->seqlock);

957

write_sequnlock(&state->seqlock);

955

spin_lock(&state->owner->so_lock);

958

spin_lock(&state->owner->so_lock);

956

update_open_stateflags(state, fmode);

959

update_open_stateflags(state, fmode);

957

spin_unlock(&state->owner->so_lock);

960

spin_unlock(&state->owner->so_lock);

958

}

961

}

959

962

960

static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)

963

static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)

961

{

964

{

962

struct nfs_inode *nfsi = NFS_I(state->inode);

965

struct nfs_inode *nfsi = NFS_I(state->inode);

963

struct nfs_delegation *deleg_cur;

966

struct nfs_delegation *deleg_cur;

964

int ret = 0;

967

int ret = 0;

965

968

966

fmode &= (FMODE_READ|FMODE_WRITE);

969

fmode &= (FMODE_READ|FMODE_WRITE);

967

970

968

rcu_read_lock();

971

rcu_read_lock();

969

deleg_cur = rcu_dereference(nfsi->delegation);

972

deleg_cur = rcu_dereference(nfsi->delegation);

970

if (deleg_cur == NULL)

973

if (deleg_cur == NULL)

971

goto no_delegation;

974

goto no_delegation;

972

975

973

spin_lock(&deleg_cur->lock);

976

spin_lock(&deleg_cur->lock);

974

if (nfsi->delegation != deleg_cur ||

977

if (nfsi->delegation != deleg_cur ||

975

(deleg_cur->type & fmode) != fmode)

978

(deleg_cur->type & fmode) != fmode)

976

goto no_delegation_unlock;

979

goto no_delegation_unlock;

977

980

978

if (delegation == NULL)

981

if (delegation == NULL)

979

delegation = &deleg_cur->stateid;

982

delegation = &deleg_cur->stateid;

980

else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0)

983

else if (memcmp(deleg_cur->stateid.data, delegation->data, NFS4_STATEID_SIZE) != 0)

981

goto no_delegation_unlock;

984

goto no_delegation_unlock;

982

985

983

nfs_mark_delegation_referenced(deleg_cur);

986

nfs_mark_delegation_referenced(deleg_cur);

984

__update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);

987

__update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);

985

ret = 1;

988

ret = 1;

986

no_delegation_unlock:

989

no_delegation_unlock:

987

spin_unlock(&deleg_cur->lock);

990

spin_unlock(&deleg_cur->lock);

988

no_delegation:

991

no_delegation:

989

rcu_read_unlock();

992

rcu_read_unlock();

990

993

991

if (!ret && open_stateid != NULL) {

994

if (!ret && open_stateid != NULL) {

992

__update_open_stateid(state, open_stateid, NULL, fmode);

995

__update_open_stateid(state, open_stateid, NULL, fmode);

993

ret = 1;

996

ret = 1;

994

}

997

}

995

998

996

return ret;

999

return ret;

997

}

1000

}

998

1001

999

1002

1000

static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)

1003

static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)

1001

{

1004

{

1002

struct nfs_delegation *delegation;

1005

struct nfs_delegation *delegation;

1003

1006

1004

rcu_read_lock();

1007

rcu_read_lock();

1005

delegation = rcu_dereference(NFS_I(inode)->delegation);

1008

delegation = rcu_dereference(NFS_I(inode)->delegation);

1006

if (delegation == NULL || (delegation->type & fmode) == fmode) {

1009

if (delegation == NULL || (delegation->type & fmode) == fmode) {

1007

rcu_read_unlock();

1010

rcu_read_unlock();

1008

return;

1011

return;

1009

}

1012

}

1010

rcu_read_unlock();

1013

rcu_read_unlock();

1011

nfs_inode_return_delegation(inode);

1014

nfs_inode_return_delegation(inode);

1012

}

1015

}

1013

1016

1014

static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)

1017

static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)

1015

{

1018

{

1016

struct nfs4_state *state = opendata->state;

1019

struct nfs4_state *state = opendata->state;

1017

struct nfs_inode *nfsi = NFS_I(state->inode);

1020

struct nfs_inode *nfsi = NFS_I(state->inode);

1018

struct nfs_delegation *delegation;

1021

struct nfs_delegation *delegation;

1019

int open_mode = opendata->o_arg.open_flags & O_EXCL;

1022

int open_mode = opendata->o_arg.open_flags & O_EXCL;

1020

fmode_t fmode = opendata->o_arg.fmode;

1023

fmode_t fmode = opendata->o_arg.fmode;

1021

nfs4_stateid stateid;

1024

nfs4_stateid stateid;

1022

int ret = -EAGAIN;

1025

int ret = -EAGAIN;

1023

1026

1024

for (;;) {

1027

for (;;) {

1025

if (can_open_cached(state, fmode, open_mode)) {

1028

if (can_open_cached(state, fmode, open_mode)) {

1026

spin_lock(&state->owner->so_lock);

1029

spin_lock(&state->owner->so_lock);

1027

if (can_open_cached(state, fmode, open_mode)) {

1030

if (can_open_cached(state, fmode, open_mode)) {

1028

update_open_stateflags(state, fmode);

1031

update_open_stateflags(state, fmode);

1029

spin_unlock(&state->owner->so_lock);

1032

spin_unlock(&state->owner->so_lock);

1030

goto out_return_state;

1033

goto out_return_state;

1031

}

1034

}

1032

spin_unlock(&state->owner->so_lock);

1035

spin_unlock(&state->owner->so_lock);

1033

}

1036

}

1034

rcu_read_lock();

1037

rcu_read_lock();

1035

delegation = rcu_dereference(nfsi->delegation);

1038

delegation = rcu_dereference(nfsi->delegation);

1036

if (delegation == NULL ||

1039

if (delegation == NULL ||

1037

!can_open_delegated(delegation, fmode)) {

1040

!can_open_delegated(delegation, fmode)) {

1038

rcu_read_unlock();

1041

rcu_read_unlock();

1039

break;

1042

break;

1040

}

1043

}

1041

/* Save the delegation */

1044

/* Save the delegation */

1042

memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));

1045

memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));

1043

rcu_read_unlock();

1046

rcu_read_unlock();

1044

ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);

1047

ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);

1045

if (ret != 0)

1048

if (ret != 0)

1046

goto out;

1049

goto out;

1047

ret = -EAGAIN;

1050

ret = -EAGAIN;

1048

1051

1049

/* Try to update the stateid using the delegation */

1052

/* Try to update the stateid using the delegation */

1050

if (update_open_stateid(state, NULL, &stateid, fmode))

1053

if (update_open_stateid(state, NULL, &stateid, fmode))

1051

goto out_return_state;

1054

goto out_return_state;

1052

}

1055

}

1053

out:

1056

out:

1054

return ERR_PTR(ret);

1057

return ERR_PTR(ret);

1055

out_return_state:

1058

out_return_state:

1056

atomic_inc(&state->count);

1059

atomic_inc(&state->count);

1057

return state;

1060

return state;

1058

}

1061

}

1059

1062

1060

static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)

1063

static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)

1061

{

1064

{

1062

struct inode *inode;

1065

struct inode *inode;

1063

struct nfs4_state *state = NULL;

1066

struct nfs4_state *state = NULL;

1064

struct nfs_delegation *delegation;

1067

struct nfs_delegation *delegation;

1065

int ret;

1068

int ret;

1066

1069

1067

if (!data->rpc_done) {

1070

if (!data->rpc_done) {

1068

state = nfs4_try_open_cached(data);

1071

state = nfs4_try_open_cached(data);

1069

goto out;

1072

goto out;

1070

}

1073

}

1071

1074

1072

ret = -EAGAIN;

1075

ret = -EAGAIN;

1073

if (!(data->f_attr.valid & NFS_ATTR_FATTR))

1076

if (!(data->f_attr.valid & NFS_ATTR_FATTR))

1074

goto err;

1077

goto err;

1075

inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);

1078

inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);

1076

ret = PTR_ERR(inode);

1079

ret = PTR_ERR(inode);

1077

if (IS_ERR(inode))

1080

if (IS_ERR(inode))

1078

goto err;

1081

goto err;

1079

ret = -ENOMEM;

1082

ret = -ENOMEM;

1080

state = nfs4_get_open_state(inode, data->owner);

1083

state = nfs4_get_open_state(inode, data->owner);

1081

if (state == NULL)

1084

if (state == NULL)

1082

goto err_put_inode;

1085

goto err_put_inode;

1083

if (data->o_res.delegation_type != 0) {

1086

if (data->o_res.delegation_type != 0) {

1084

int delegation_flags = 0;

1087

int delegation_flags = 0;

1085

1088

1086

rcu_read_lock();

1089

rcu_read_lock();

1087

delegation = rcu_dereference(NFS_I(inode)->delegation);

1090

delegation = rcu_dereference(NFS_I(inode)->delegation);

1088

if (delegation)

1091

if (delegation)

1089

delegation_flags = delegation->flags;

1092

delegation_flags = delegation->flags;

1090

rcu_read_unlock();

1093

rcu_read_unlock();

1091

if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)

1094

if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)

1092

nfs_inode_set_delegation(state->inode,

1095

nfs_inode_set_delegation(state->inode,

1093

data->owner->so_cred,

1096

data->owner->so_cred,

1094

&data->o_res);

1097

&data->o_res);

1095

else

1098

else

1096

nfs_inode_reclaim_delegation(state->inode,

1099

nfs_inode_reclaim_delegation(state->inode,

1097

data->owner->so_cred,

1100

data->owner->so_cred,

1098

&data->o_res);

1101

&data->o_res);

1099

}

1102

}

1100

1103

1101

update_open_stateid(state, &data->o_res.stateid, NULL,

1104

update_open_stateid(state, &data->o_res.stateid, NULL,

1102

data->o_arg.fmode);

1105

data->o_arg.fmode);

1103

iput(inode);

1106

iput(inode);

1104

out:

1107

out:

1105

return state;

1108

return state;

1106

err_put_inode:

1109

err_put_inode:

1107

iput(inode);

1110

iput(inode);

1108

err:

1111

err:

1109

return ERR_PTR(ret);

1112

return ERR_PTR(ret);

1110

}

1113

}

1111

1114

1112

static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)

1115

static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)

1113

{

1116

{

1114

struct nfs_inode *nfsi = NFS_I(state->inode);

1117

struct nfs_inode *nfsi = NFS_I(state->inode);

1115

struct nfs_open_context *ctx;

1118

struct nfs_open_context *ctx;

1116

1119

1117

spin_lock(&state->inode->i_lock);

1120

spin_lock(&state->inode->i_lock);

1118

list_for_each_entry(ctx, &nfsi->open_files, list) {

1121

list_for_each_entry(ctx, &nfsi->open_files, list) {

1119

if (ctx->state != state)

1122

if (ctx->state != state)

1120

continue;

1123

continue;

1121

get_nfs_open_context(ctx);

1124

get_nfs_open_context(ctx);

1122

spin_unlock(&state->inode->i_lock);

1125

spin_unlock(&state->inode->i_lock);

1123

return ctx;

1126

return ctx;

1124

}

1127

}

1125

spin_unlock(&state->inode->i_lock);

1128

spin_unlock(&state->inode->i_lock);

1126

return ERR_PTR(-ENOENT);

1129

return ERR_PTR(-ENOENT);

1127

}

1130

}

1128

1131

1129

static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)

1132

static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)

1130

{

1133

{

1131

struct nfs4_opendata *opendata;

1134

struct nfs4_opendata *opendata;

1132

1135

1133

opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL, GFP_NOFS);

1136

opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, 0, NULL, GFP_NOFS);

1134

if (opendata == NULL)

1137

if (opendata == NULL)

1135

return ERR_PTR(-ENOMEM);

1138

return ERR_PTR(-ENOMEM);

1136

opendata->state = state;

1139

opendata->state = state;

1137

atomic_inc(&state->count);

1140

atomic_inc(&state->count);

1138

return opendata;

1141

return opendata;

1139

}

1142

}

1140

1143

1141

static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)

1144

static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)

1142

{

1145

{

1143

struct nfs4_state *newstate;

1146

struct nfs4_state *newstate;

1144

int ret;

1147

int ret;

1145

1148

1146

opendata->o_arg.open_flags = 0;

1149

opendata->o_arg.open_flags = 0;

1147

opendata->o_arg.fmode = fmode;

1150

opendata->o_arg.fmode = fmode;

1148

memset(&opendata->o_res, 0, sizeof(opendata->o_res));

1151

memset(&opendata->o_res, 0, sizeof(opendata->o_res));

1149

memset(&opendata->c_res, 0, sizeof(opendata->c_res));

1152

memset(&opendata->c_res, 0, sizeof(opendata->c_res));

1150

nfs4_init_opendata_res(opendata);

1153

nfs4_init_opendata_res(opendata);

1151

ret = _nfs4_recover_proc_open(opendata);

1154

ret = _nfs4_recover_proc_open(opendata);

1152

if (ret != 0)

1155

if (ret != 0)

1153

return ret;

1156

return ret;

1154

newstate = nfs4_opendata_to_nfs4_state(opendata);

1157

newstate = nfs4_opendata_to_nfs4_state(opendata);

1155

if (IS_ERR(newstate))

1158

if (IS_ERR(newstate))

1156

return PTR_ERR(newstate);

1159

return PTR_ERR(newstate);

1157

nfs4_close_state(&opendata->path, newstate, fmode);

1160

nfs4_close_state(&opendata->path, newstate, fmode);

1158

*res = newstate;

1161

*res = newstate;

1159

return 0;

1162

return 0;

1160

}

1163

}

1161

1164

1162

static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)

1165

static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)

1163

{

1166

{

1164

struct nfs4_state *newstate;

1167

struct nfs4_state *newstate;

1165

int ret;

1168

int ret;

1166

1169

1167

/* memory barrier prior to reading state->n_* */

1170

/* memory barrier prior to reading state->n_* */

1168

clear_bit(NFS_DELEGATED_STATE, &state->flags);

1171

clear_bit(NFS_DELEGATED_STATE, &state->flags);

1169

smp_rmb();

1172

smp_rmb();

1170

if (state->n_rdwr != 0) {

1173

if (state->n_rdwr != 0) {

1171

clear_bit(NFS_O_RDWR_STATE, &state->flags);

1174

clear_bit(NFS_O_RDWR_STATE, &state->flags);

1172

ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);

1175

ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);

1173

if (ret != 0)

1176

if (ret != 0)

1174

return ret;

1177

return ret;

1175

if (newstate != state)

1178

if (newstate != state)

1176

return -ESTALE;

1179

return -ESTALE;

1177

}

1180

}

1178

if (state->n_wronly != 0) {

1181

if (state->n_wronly != 0) {

1179

clear_bit(NFS_O_WRONLY_STATE, &state->flags);

1182

clear_bit(NFS_O_WRONLY_STATE, &state->flags);

1180

ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);

1183

ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);

1181

if (ret != 0)

1184

if (ret != 0)

1182

return ret;

1185

return ret;

1183

if (newstate != state)

1186

if (newstate != state)

1184

return -ESTALE;

1187

return -ESTALE;

1185

}

1188

}

1186

if (state->n_rdonly != 0) {

1189

if (state->n_rdonly != 0) {

1187

clear_bit(NFS_O_RDONLY_STATE, &state->flags);

1190

clear_bit(NFS_O_RDONLY_STATE, &state->flags);

1188

ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);

1191

ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);

1189

if (ret != 0)

1192

if (ret != 0)

1190

return ret;

1193

return ret;

1191

if (newstate != state)

1194

if (newstate != state)

1192

return -ESTALE;

1195

return -ESTALE;

1193

}

1196

}

1194

/*

1197

/*

1195

* We may have performed cached opens for all three recoveries.

1198

* We may have performed cached opens for all three recoveries.

1196

* Check if we need to update the current stateid.

1199

* Check if we need to update the current stateid.

1197

*/

1200

*/

1198

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&

1201

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&

1199

memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {

1202

memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {

1200

write_seqlock(&state->seqlock);

1203

write_seqlock(&state->seqlock);

1201

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)

1204

if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)

1202

memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));

1205

memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));

1203

write_sequnlock(&state->seqlock);

1206

write_sequnlock(&state->seqlock);

1204

}

1207

}

1205

return 0;

1208

return 0;

1206

}

1209

}

1207

1210

1208

/*

1211

/*

1209

* OPEN_RECLAIM:

1212

* OPEN_RECLAIM:

1210

* reclaim state on the server after a reboot.

1213

* reclaim state on the server after a reboot.

1211

*/

1214

*/

1212

static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)

1215

static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)

1213

{

1216

{

1214

struct nfs_delegation *delegation;

1217

struct nfs_delegation *delegation;

1215

struct nfs4_opendata *opendata;

1218

struct nfs4_opendata *opendata;

1216

fmode_t delegation_type = 0;

1219

fmode_t delegation_type = 0;

1217

int status;

1220

int status;

1218

1221

1219

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1222

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1220

if (IS_ERR(opendata))

1223

if (IS_ERR(opendata))

1221

return PTR_ERR(opendata);

1224

return PTR_ERR(opendata);

1222

opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;

1225

opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;

1223

opendata->o_arg.fh = NFS_FH(state->inode);

1226

opendata->o_arg.fh = NFS_FH(state->inode);

1224

rcu_read_lock();

1227

rcu_read_lock();

1225

delegation = rcu_dereference(NFS_I(state->inode)->delegation);

1228

delegation = rcu_dereference(NFS_I(state->inode)->delegation);

1226

if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)

1229

if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)

1227

delegation_type = delegation->type;

1230

delegation_type = delegation->type;

1228

rcu_read_unlock();

1231

rcu_read_unlock();

1229

opendata->o_arg.u.delegation_type = delegation_type;

1232

opendata->o_arg.u.delegation_type = delegation_type;

1230

status = nfs4_open_recover(opendata, state);

1233

status = nfs4_open_recover(opendata, state);

1231

nfs4_opendata_put(opendata);

1234

nfs4_opendata_put(opendata);

1232

return status;

1235

return status;

1233

}

1236

}

1234

1237

1235

static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)

1238

static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)

1236

{

1239

{

1237

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

1240

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

1238

struct nfs4_exception exception = { };

1241

struct nfs4_exception exception = { };

1239

int err;

1242

int err;

1240

do {

1243

do {

1241

err = _nfs4_do_open_reclaim(ctx, state);

1244

err = _nfs4_do_open_reclaim(ctx, state);

1242

if (err != -NFS4ERR_DELAY)

1245

if (err != -NFS4ERR_DELAY)

1243

break;

1246

break;

1244

nfs4_handle_exception(server, err, &exception);

1247

nfs4_handle_exception(server, err, &exception);

1245

} while (exception.retry);

1248

} while (exception.retry);

1246

return err;

1249

return err;

1247

}

1250

}

1248

1251

1249

static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)

1252

static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)

1250

{

1253

{

1251

struct nfs_open_context *ctx;

1254

struct nfs_open_context *ctx;

1252

int ret;

1255

int ret;

1253

1256

1254

ctx = nfs4_state_find_open_context(state);

1257

ctx = nfs4_state_find_open_context(state);

1255

if (IS_ERR(ctx))

1258

if (IS_ERR(ctx))

1256

return PTR_ERR(ctx);

1259

return PTR_ERR(ctx);

1257

ret = nfs4_do_open_reclaim(ctx, state);

1260

ret = nfs4_do_open_reclaim(ctx, state);

1258

put_nfs_open_context(ctx);

1261

put_nfs_open_context(ctx);

1259

return ret;

1262

return ret;

1260

}

1263

}

1261

1264

1262

static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)

1265

static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)

1263

{

1266

{

1264

struct nfs4_opendata *opendata;

1267

struct nfs4_opendata *opendata;

1265

int ret;

1268

int ret;

1266

1269

1267

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1270

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1268

if (IS_ERR(opendata))

1271

if (IS_ERR(opendata))

1269

return PTR_ERR(opendata);

1272

return PTR_ERR(opendata);

1270

opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;

1273

opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;

1271

memcpy(opendata->o_arg.u.delegation.data, stateid->data,

1274

memcpy(opendata->o_arg.u.delegation.data, stateid->data,

1272

sizeof(opendata->o_arg.u.delegation.data));

1275

sizeof(opendata->o_arg.u.delegation.data));

1273

ret = nfs4_open_recover(opendata, state);

1276

ret = nfs4_open_recover(opendata, state);

1274

nfs4_opendata_put(opendata);

1277

nfs4_opendata_put(opendata);

1275

return ret;

1278

return ret;

1276

}

1279

}

1277

1280

1278

int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)

1281

int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)

1279

{

1282

{

1280

struct nfs4_exception exception = { };

1283

struct nfs4_exception exception = { };

1281

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

1284

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

1282

int err;

1285

int err;

1283

do {

1286

do {

1284

err = _nfs4_open_delegation_recall(ctx, state, stateid);

1287

err = _nfs4_open_delegation_recall(ctx, state, stateid);

1285

switch (err) {

1288

switch (err) {

1286

case 0:

1289

case 0:

1287

case -ENOENT:

1290

case -ENOENT:

1288

case -ESTALE:

1291

case -ESTALE:

1289

goto out;

1292

goto out;

1290

case -NFS4ERR_BADSESSION:

1293

case -NFS4ERR_BADSESSION:

1291

case -NFS4ERR_BADSLOT:

1294

case -NFS4ERR_BADSLOT:

1292

case -NFS4ERR_BAD_HIGH_SLOT:

1295

case -NFS4ERR_BAD_HIGH_SLOT:

1293

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

1296

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

1294

case -NFS4ERR_DEADSESSION:

1297

case -NFS4ERR_DEADSESSION:

1295

nfs4_schedule_session_recovery(server->nfs_client->cl_session);

1298

nfs4_schedule_session_recovery(server->nfs_client->cl_session);

1296

goto out;

1299

goto out;

1297

case -NFS4ERR_STALE_CLIENTID:

1300

case -NFS4ERR_STALE_CLIENTID:

1298

case -NFS4ERR_STALE_STATEID:

1301

case -NFS4ERR_STALE_STATEID:

1299

case -NFS4ERR_EXPIRED:

1302

case -NFS4ERR_EXPIRED:

1300

/* Don't recall a delegation if it was lost */

1303

/* Don't recall a delegation if it was lost */

1301

nfs4_schedule_lease_recovery(server->nfs_client);

1304

nfs4_schedule_lease_recovery(server->nfs_client);

1302

goto out;

1305

goto out;

1303

case -ERESTARTSYS:

1306

case -ERESTARTSYS:

1304

/*

1307

/*

1305

* The show must go on: exit, but mark the

1308

* The show must go on: exit, but mark the

1306

* stateid as needing recovery.

1309

* stateid as needing recovery.

1307

*/

1310

*/

1308

case -NFS4ERR_ADMIN_REVOKED:

1311

case -NFS4ERR_ADMIN_REVOKED:

1309

case -NFS4ERR_BAD_STATEID:

1312

case -NFS4ERR_BAD_STATEID:

1310

nfs4_schedule_stateid_recovery(server, state);

1313

nfs4_schedule_stateid_recovery(server, state);

1311

case -EKEYEXPIRED:

1314

case -EKEYEXPIRED:

1312

/*

1315

/*

1313

* User RPCSEC_GSS context has expired.

1316

* User RPCSEC_GSS context has expired.

1314

* We cannot recover this stateid now, so

1317

* We cannot recover this stateid now, so

1315

* skip it and allow recovery thread to

1318

* skip it and allow recovery thread to

1316

* proceed.

1319

* proceed.

1317

*/

1320

*/

1318

case -ENOMEM:

1321

case -ENOMEM:

1319

err = 0;

1322

err = 0;

1320

goto out;

1323

goto out;

1321

}

1324

}

1322

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

1325

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

1323

} while (exception.retry);

1326

} while (exception.retry);

1324

out:

1327

out:

1325

return err;

1328

return err;

1326

}

1329

}

1327

1330

1328

static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)

1331

static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)

1329

{

1332

{

1330

struct nfs4_opendata *data = calldata;

1333

struct nfs4_opendata *data = calldata;

1331

1334

1332

data->rpc_status = task->tk_status;

1335

data->rpc_status = task->tk_status;

1333

if (data->rpc_status == 0) {

1336

if (data->rpc_status == 0) {

1334

memcpy(data->o_res.stateid.data, data->c_res.stateid.data,

1337

memcpy(data->o_res.stateid.data, data->c_res.stateid.data,

1335

sizeof(data->o_res.stateid.data));

1338

sizeof(data->o_res.stateid.data));

1336

nfs_confirm_seqid(&data->owner->so_seqid, 0);

1339

nfs_confirm_seqid(&data->owner->so_seqid, 0);

1337

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

1340

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

1338

data->rpc_done = 1;

1341

data->rpc_done = 1;

1339

}

1342

}

1340

}

1343

}

1341

1344

1342

static void nfs4_open_confirm_release(void *calldata)

1345

static void nfs4_open_confirm_release(void *calldata)

1343

{

1346

{

1344

struct nfs4_opendata *data = calldata;

1347

struct nfs4_opendata *data = calldata;

1345

struct nfs4_state *state = NULL;

1348

struct nfs4_state *state = NULL;

1346

1349

1347

/* If this request hasn't been cancelled, do nothing */

1350

/* If this request hasn't been cancelled, do nothing */

1348

if (data->cancelled == 0)

1351

if (data->cancelled == 0)

1349

goto out_free;

1352

goto out_free;

1350

/* In case of error, no cleanup! */

1353

/* In case of error, no cleanup! */

1351

if (!data->rpc_done)

1354

if (!data->rpc_done)

1352

goto out_free;

1355

goto out_free;

1353

state = nfs4_opendata_to_nfs4_state(data);

1356

state = nfs4_opendata_to_nfs4_state(data);

1354

if (!IS_ERR(state))

1357

if (!IS_ERR(state))

1355

nfs4_close_state(&data->path, state, data->o_arg.fmode);

1358

nfs4_close_state(&data->path, state, data->o_arg.fmode);

1356

out_free:

1359

out_free:

1357

nfs4_opendata_put(data);

1360

nfs4_opendata_put(data);

1358

}

1361

}

1359

1362

1360

static const struct rpc_call_ops nfs4_open_confirm_ops = {

1363

static const struct rpc_call_ops nfs4_open_confirm_ops = {

1361

.rpc_call_done = nfs4_open_confirm_done,

1364

.rpc_call_done = nfs4_open_confirm_done,

1362

.rpc_release = nfs4_open_confirm_release,

1365

.rpc_release = nfs4_open_confirm_release,

1363

};

1366

};

1364

1367

1365

/*

1368

/*

1366

* Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata

1369

* Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata

1367

*/

1370

*/

1368

static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)

1371

static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)

1369

{

1372

{

1370

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

1373

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

1371

struct rpc_task *task;

1374

struct rpc_task *task;

1372

struct rpc_message msg = {

1375

struct rpc_message msg = {

1373

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],

1376

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],

1374

.rpc_argp = &data->c_arg,

1377

.rpc_argp = &data->c_arg,

1375

.rpc_resp = &data->c_res,

1378

.rpc_resp = &data->c_res,

1376

.rpc_cred = data->owner->so_cred,

1379

.rpc_cred = data->owner->so_cred,

1377

};

1380

};

1378

struct rpc_task_setup task_setup_data = {

1381

struct rpc_task_setup task_setup_data = {

1379

.rpc_client = server->client,

1382

.rpc_client = server->client,

1380

.rpc_message = &msg,

1383

.rpc_message = &msg,

1381

.callback_ops = &nfs4_open_confirm_ops,

1384

.callback_ops = &nfs4_open_confirm_ops,

1382

.callback_data = data,

1385

.callback_data = data,

1383

.workqueue = nfsiod_workqueue,

1386

.workqueue = nfsiod_workqueue,

1384

.flags = RPC_TASK_ASYNC,

1387

.flags = RPC_TASK_ASYNC,

1385

};

1388

};

1386

int status;

1389

int status;

1387

1390

1388

kref_get(&data->kref);

1391

kref_get(&data->kref);

1389

data->rpc_done = 0;

1392

data->rpc_done = 0;

1390

data->rpc_status = 0;

1393

data->rpc_status = 0;

1391

data->timestamp = jiffies;

1394

data->timestamp = jiffies;

1392

task = rpc_run_task(&task_setup_data);

1395

task = rpc_run_task(&task_setup_data);

1393

if (IS_ERR(task))

1396

if (IS_ERR(task))

1394

return PTR_ERR(task);

1397

return PTR_ERR(task);

1395

status = nfs4_wait_for_completion_rpc_task(task);

1398

status = nfs4_wait_for_completion_rpc_task(task);

1396

if (status != 0) {

1399

if (status != 0) {

1397

data->cancelled = 1;

1400

data->cancelled = 1;

1398

smp_wmb();

1401

smp_wmb();

1399

} else

1402

} else

1400

status = data->rpc_status;

1403

status = data->rpc_status;

1401

rpc_put_task(task);

1404

rpc_put_task(task);

1402

return status;

1405

return status;

1403

}

1406

}

1404

1407

1405

static void nfs4_open_prepare(struct rpc_task *task, void *calldata)

1408

static void nfs4_open_prepare(struct rpc_task *task, void *calldata)

1406

{

1409

{

1407

struct nfs4_opendata *data = calldata;

1410

struct nfs4_opendata *data = calldata;

1408

struct nfs4_state_owner *sp = data->owner;

1411

struct nfs4_state_owner *sp = data->owner;

1409

1412

1410

if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)

1413

if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)

1411

return;

1414

return;

1412

/*

1415

/*

1413

* Check if we still need to send an OPEN call, or if we can use

1416

* Check if we still need to send an OPEN call, or if we can use

1414

* a delegation instead.

1417

* a delegation instead.

1415

*/

1418

*/

1416

if (data->state != NULL) {

1419

if (data->state != NULL) {

1417

struct nfs_delegation *delegation;

1420

struct nfs_delegation *delegation;

1418

1421

1419

if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))

1422

if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))

1420

goto out_no_action;

1423

goto out_no_action;

1421

rcu_read_lock();

1424

rcu_read_lock();

1422

delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);

1425

delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);

1423

if (delegation != NULL &&

1426

if (delegation != NULL &&

1424

test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) {

1427

test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) {

1425

rcu_read_unlock();

1428

rcu_read_unlock();

1426

goto out_no_action;

1429

goto out_no_action;

1427

}

1430

}

1428

rcu_read_unlock();

1431

rcu_read_unlock();

1429

}

1432

}

1430

/* Update sequence id. */

1433

/* Update sequence id. */

1431

data->o_arg.id = sp->so_owner_id.id;

1434

data->o_arg.id = sp->so_owner_id.id;

1432

data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid;

1435

data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid;

1433

if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {

1436

if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {

1434

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];

1437

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];

1435

nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);

1438

nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);

1436

}

1439

}

1437

data->timestamp = jiffies;

1440

data->timestamp = jiffies;

1438

if (nfs4_setup_sequence(data->o_arg.server,

1441

if (nfs4_setup_sequence(data->o_arg.server,

1439

&data->o_arg.seq_args,

1442

&data->o_arg.seq_args,

1440

&data->o_res.seq_res, 1, task))

1443

&data->o_res.seq_res, 1, task))

1441

return;

1444

return;

1442

rpc_call_start(task);

1445

rpc_call_start(task);

1443

return;

1446

return;

1444

out_no_action:

1447

out_no_action:

1445

task->tk_action = NULL;

1448

task->tk_action = NULL;

1446

1449

1447

}

1450

}

1448

1451

1449

static void nfs4_recover_open_prepare(struct rpc_task *task, void *calldata)

1452

static void nfs4_recover_open_prepare(struct rpc_task *task, void *calldata)

1450

{

1453

{

1451

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

1454

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

1452

nfs4_open_prepare(task, calldata);

1455

nfs4_open_prepare(task, calldata);

1453

}

1456

}

1454

1457

1455

static void nfs4_open_done(struct rpc_task *task, void *calldata)

1458

static void nfs4_open_done(struct rpc_task *task, void *calldata)

1456

{

1459

{

1457

struct nfs4_opendata *data = calldata;

1460

struct nfs4_opendata *data = calldata;

1458

1461

1459

data->rpc_status = task->tk_status;

1462

data->rpc_status = task->tk_status;

1460

1463

1461

if (!nfs4_sequence_done(task, &data->o_res.seq_res))

1464

if (!nfs4_sequence_done(task, &data->o_res.seq_res))

1462

return;

1465

return;

1463

1466

1464

if (task->tk_status == 0) {

1467

if (task->tk_status == 0) {

1465

switch (data->o_res.f_attr->mode & S_IFMT) {

1468

switch (data->o_res.f_attr->mode & S_IFMT) {

1466

case S_IFREG:

1469

case S_IFREG:

1467

break;

1470

break;

1468

case S_IFLNK:

1471

case S_IFLNK:

1469

data->rpc_status = -ELOOP;

1472

data->rpc_status = -ELOOP;

1470

break;

1473

break;

1471

case S_IFDIR:

1474

case S_IFDIR:

1472

data->rpc_status = -EISDIR;

1475

data->rpc_status = -EISDIR;

1473

break;

1476

break;

1474

default:

1477

default:

1475

data->rpc_status = -ENOTDIR;

1478

data->rpc_status = -ENOTDIR;

1476

}

1479

}

1477

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

1480

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

1478

if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))

1481

if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))

1479

nfs_confirm_seqid(&data->owner->so_seqid, 0);

1482

nfs_confirm_seqid(&data->owner->so_seqid, 0);

1480

}

1483

}

1481

data->rpc_done = 1;

1484

data->rpc_done = 1;

1482

}

1485

}

1483

1486

1484

static void nfs4_open_release(void *calldata)

1487

static void nfs4_open_release(void *calldata)

1485

{

1488

{

1486

struct nfs4_opendata *data = calldata;

1489

struct nfs4_opendata *data = calldata;

1487

struct nfs4_state *state = NULL;

1490

struct nfs4_state *state = NULL;

1488

1491

1489

/* If this request hasn't been cancelled, do nothing */

1492

/* If this request hasn't been cancelled, do nothing */

1490

if (data->cancelled == 0)

1493

if (data->cancelled == 0)

1491

goto out_free;

1494

goto out_free;

1492

/* In case of error, no cleanup! */

1495

/* In case of error, no cleanup! */

1493

if (data->rpc_status != 0 || !data->rpc_done)

1496

if (data->rpc_status != 0 || !data->rpc_done)

1494

goto out_free;

1497

goto out_free;

1495

/* In case we need an open_confirm, no cleanup! */

1498

/* In case we need an open_confirm, no cleanup! */

1496

if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)

1499

if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)

1497

goto out_free;

1500

goto out_free;

1498

state = nfs4_opendata_to_nfs4_state(data);

1501

state = nfs4_opendata_to_nfs4_state(data);

1499

if (!IS_ERR(state))

1502

if (!IS_ERR(state))

1500

nfs4_close_state(&data->path, state, data->o_arg.fmode);

1503

nfs4_close_state(&data->path, state, data->o_arg.fmode);

1501

out_free:

1504

out_free:

1502

nfs4_opendata_put(data);

1505

nfs4_opendata_put(data);

1503

}

1506

}

1504

1507

1505

static const struct rpc_call_ops nfs4_open_ops = {

1508

static const struct rpc_call_ops nfs4_open_ops = {

1506

.rpc_call_prepare = nfs4_open_prepare,

1509

.rpc_call_prepare = nfs4_open_prepare,

1507

.rpc_call_done = nfs4_open_done,

1510

.rpc_call_done = nfs4_open_done,

1508

.rpc_release = nfs4_open_release,

1511

.rpc_release = nfs4_open_release,

1509

};

1512

};

1510

1513

1511

static const struct rpc_call_ops nfs4_recover_open_ops = {

1514

static const struct rpc_call_ops nfs4_recover_open_ops = {

1512

.rpc_call_prepare = nfs4_recover_open_prepare,

1515

.rpc_call_prepare = nfs4_recover_open_prepare,

1513

.rpc_call_done = nfs4_open_done,

1516

.rpc_call_done = nfs4_open_done,

1514

.rpc_release = nfs4_open_release,

1517

.rpc_release = nfs4_open_release,

1515

};

1518

};

1516

1519

1517

static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)

1520

static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)

1518

{

1521

{

1519

struct inode *dir = data->dir->d_inode;

1522

struct inode *dir = data->dir->d_inode;

1520

struct nfs_server *server = NFS_SERVER(dir);

1523

struct nfs_server *server = NFS_SERVER(dir);

1521

struct nfs_openargs *o_arg = &data->o_arg;

1524

struct nfs_openargs *o_arg = &data->o_arg;

1522

struct nfs_openres *o_res = &data->o_res;

1525

struct nfs_openres *o_res = &data->o_res;

1523

struct rpc_task *task;

1526

struct rpc_task *task;

1524

struct rpc_message msg = {

1527

struct rpc_message msg = {

1525

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],

1528

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],

1526

.rpc_argp = o_arg,

1529

.rpc_argp = o_arg,

1527

.rpc_resp = o_res,

1530

.rpc_resp = o_res,

1528

.rpc_cred = data->owner->so_cred,

1531

.rpc_cred = data->owner->so_cred,

1529

};

1532

};

1530

struct rpc_task_setup task_setup_data = {

1533

struct rpc_task_setup task_setup_data = {

1531

.rpc_client = server->client,

1534

.rpc_client = server->client,

1532

.rpc_message = &msg,

1535

.rpc_message = &msg,

1533

.callback_ops = &nfs4_open_ops,

1536

.callback_ops = &nfs4_open_ops,

1534

.callback_data = data,

1537

.callback_data = data,

1535

.workqueue = nfsiod_workqueue,

1538

.workqueue = nfsiod_workqueue,

1536

.flags = RPC_TASK_ASYNC,

1539

.flags = RPC_TASK_ASYNC,

1537

};

1540

};

1538

int status;

1541

int status;

1539

1542

1540

kref_get(&data->kref);

1543

kref_get(&data->kref);

1541

data->rpc_done = 0;

1544

data->rpc_done = 0;

1542

data->rpc_status = 0;

1545

data->rpc_status = 0;

1543

data->cancelled = 0;

1546

data->cancelled = 0;

1544

if (isrecover)

1547

if (isrecover)

1545

task_setup_data.callback_ops = &nfs4_recover_open_ops;

1548

task_setup_data.callback_ops = &nfs4_recover_open_ops;

1546

task = rpc_run_task(&task_setup_data);

1549

task = rpc_run_task(&task_setup_data);

1547

if (IS_ERR(task))

1550

if (IS_ERR(task))

1548

return PTR_ERR(task);

1551

return PTR_ERR(task);

1549

status = nfs4_wait_for_completion_rpc_task(task);

1552

status = nfs4_wait_for_completion_rpc_task(task);

1550

if (status != 0) {

1553

if (status != 0) {

1551

data->cancelled = 1;

1554

data->cancelled = 1;

1552

smp_wmb();

1555

smp_wmb();

1553

} else

1556

} else

1554

status = data->rpc_status;

1557

status = data->rpc_status;

1555

rpc_put_task(task);

1558

rpc_put_task(task);

1556

1559

1557

return status;

1560

return status;

1558

}

1561

}

1559

1562

1560

static int _nfs4_recover_proc_open(struct nfs4_opendata *data)

1563

static int _nfs4_recover_proc_open(struct nfs4_opendata *data)

1561

{

1564

{

1562

struct inode *dir = data->dir->d_inode;

1565

struct inode *dir = data->dir->d_inode;

1563

struct nfs_openres *o_res = &data->o_res;

1566

struct nfs_openres *o_res = &data->o_res;

1564

int status;

1567

int status;

1565

1568

1566

status = nfs4_run_open_task(data, 1);

1569

status = nfs4_run_open_task(data, 1);

1567

if (status != 0 || !data->rpc_done)

1570

if (status != 0 || !data->rpc_done)

1568

return status;

1571

return status;

1569

1572

1570

nfs_refresh_inode(dir, o_res->dir_attr);

1573

nfs_refresh_inode(dir, o_res->dir_attr);

1571

1574

1572

if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {

1575

if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {

1573

status = _nfs4_proc_open_confirm(data);

1576

status = _nfs4_proc_open_confirm(data);

1574

if (status != 0)

1577

if (status != 0)

1575

return status;

1578

return status;

1576

}

1579

}

1577

1580

1578

return status;

1581

return status;

1579

}

1582

}

1580

1583

1581

/*

1584

/*

1582

* Note: On error, nfs4_proc_open will free the struct nfs4_opendata

1585

* Note: On error, nfs4_proc_open will free the struct nfs4_opendata

1583

*/

1586

*/

1584

static int _nfs4_proc_open(struct nfs4_opendata *data)

1587

static int _nfs4_proc_open(struct nfs4_opendata *data)

1585

{

1588

{

1586

struct inode *dir = data->dir->d_inode;

1589

struct inode *dir = data->dir->d_inode;

1587

struct nfs_server *server = NFS_SERVER(dir);

1590

struct nfs_server *server = NFS_SERVER(dir);

1588

struct nfs_openargs *o_arg = &data->o_arg;

1591

struct nfs_openargs *o_arg = &data->o_arg;

1589

struct nfs_openres *o_res = &data->o_res;

1592

struct nfs_openres *o_res = &data->o_res;

1590

int status;

1593

int status;

1591

1594

1592

status = nfs4_run_open_task(data, 0);

1595

status = nfs4_run_open_task(data, 0);

1593

if (status != 0 || !data->rpc_done)

1596

if (status != 0 || !data->rpc_done)

1594

return status;

1597

return status;

1595

1598

1596

if (o_arg->open_flags & O_CREAT) {

1599

if (o_arg->open_flags & O_CREAT) {

1597

update_changeattr(dir, &o_res->cinfo);

1600

update_changeattr(dir, &o_res->cinfo);

1598

nfs_post_op_update_inode(dir, o_res->dir_attr);

1601

nfs_post_op_update_inode(dir, o_res->dir_attr);

1599

} else

1602

} else

1600

nfs_refresh_inode(dir, o_res->dir_attr);

1603

nfs_refresh_inode(dir, o_res->dir_attr);

1601

if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)

1604

if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)

1602

server->caps &= ~NFS_CAP_POSIX_LOCK;

1605

server->caps &= ~NFS_CAP_POSIX_LOCK;

1603

if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {

1606

if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {

1604

status = _nfs4_proc_open_confirm(data);

1607

status = _nfs4_proc_open_confirm(data);

1605

if (status != 0)

1608

if (status != 0)

1606

return status;

1609

return status;

1607

}

1610

}

1608

if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))

1611

if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))

1609

_nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);

1612

_nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);

1610

return 0;

1613

return 0;

1611

}

1614

}

1612

1615

1613

static int nfs4_client_recover_expired_lease(struct nfs_client *clp)

1616

static int nfs4_client_recover_expired_lease(struct nfs_client *clp)

1614

{

1617

{

1615

unsigned int loop;

1618

unsigned int loop;

1616

int ret;

1619

int ret;

1617

1620

1618

for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {

1621

for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {

1619

ret = nfs4_wait_clnt_recover(clp);

1622

ret = nfs4_wait_clnt_recover(clp);

1620

if (ret != 0)

1623

if (ret != 0)

1621

break;

1624

break;

1622

if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&

1625

if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&

1623

!test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))

1626

!test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))

1624

break;

1627

break;

1625

nfs4_schedule_state_manager(clp);

1628

nfs4_schedule_state_manager(clp);

1626

ret = -EIO;

1629

ret = -EIO;

1627

}

1630

}

1628

return ret;

1631

return ret;

1629

}

1632

}

1630

1633

1631

static int nfs4_recover_expired_lease(struct nfs_server *server)

1634

static int nfs4_recover_expired_lease(struct nfs_server *server)

1632

{

1635

{

1633

return nfs4_client_recover_expired_lease(server->nfs_client);

1636

return nfs4_client_recover_expired_lease(server->nfs_client);

1634

}

1637

}

1635

1638

1636

/*

1639

/*

1637

* OPEN_EXPIRED:

1640

* OPEN_EXPIRED:

1638

* reclaim state on the server after a network partition.

1641

* reclaim state on the server after a network partition.

1639

* Assumes caller holds the appropriate lock

1642

* Assumes caller holds the appropriate lock

1640

*/

1643

*/

1641

static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)

1644

static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)

1642

{

1645

{

1643

struct nfs4_opendata *opendata;

1646

struct nfs4_opendata *opendata;

1644

int ret;

1647

int ret;

1645

1648

1646

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1649

opendata = nfs4_open_recoverdata_alloc(ctx, state);

1647

if (IS_ERR(opendata))

1650

if (IS_ERR(opendata))

1648

return PTR_ERR(opendata);

1651

return PTR_ERR(opendata);

1649

ret = nfs4_open_recover(opendata, state);

1652

ret = nfs4_open_recover(opendata, state);

1650

if (ret == -ESTALE)

1653

if (ret == -ESTALE)

1651

d_drop(ctx->path.dentry);

1654

d_drop(ctx->path.dentry);

1652

nfs4_opendata_put(opendata);

1655

nfs4_opendata_put(opendata);

1653

return ret;

1656

return ret;

1654

}

1657

}

1655

1658

1656

static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)

1659

static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)

1657

{

1660

{

1658

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

1661

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

1659

struct nfs4_exception exception = { };

1662

struct nfs4_exception exception = { };

1660

int err;

1663

int err;

1661

1664

1662

do {

1665

do {

1663

err = _nfs4_open_expired(ctx, state);

1666

err = _nfs4_open_expired(ctx, state);

1664

switch (err) {

1667

switch (err) {

1665

default:

1668

default:

1666

goto out;

1669

goto out;

1667

case -NFS4ERR_GRACE:

1670

case -NFS4ERR_GRACE:

1668

case -NFS4ERR_DELAY:

1671

case -NFS4ERR_DELAY:

1669

nfs4_handle_exception(server, err, &exception);

1672

nfs4_handle_exception(server, err, &exception);

1670

err = 0;

1673

err = 0;

1671

}

1674

}

1672

} while (exception.retry);

1675

} while (exception.retry);

1673

out:

1676

out:

1674

return err;

1677

return err;

1675

}

1678

}

1676

1679

1677

static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)

1680

static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)

1678

{

1681

{

1679

struct nfs_open_context *ctx;

1682

struct nfs_open_context *ctx;

1680

int ret;

1683

int ret;

1681

1684

1682

ctx = nfs4_state_find_open_context(state);

1685

ctx = nfs4_state_find_open_context(state);

1683

if (IS_ERR(ctx))

1686

if (IS_ERR(ctx))

1684

return PTR_ERR(ctx);

1687

return PTR_ERR(ctx);

1685

ret = nfs4_do_open_expired(ctx, state);

1688

ret = nfs4_do_open_expired(ctx, state);

1686

put_nfs_open_context(ctx);

1689

put_nfs_open_context(ctx);

1687

return ret;

1690

return ret;

1688

}

1691

}

1689

1692

1693

#if defined(CONFIG_NFS_V4_1)

1694

static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)

1695

{

1696

int status;

1697

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

1698

1699

status = nfs41_test_stateid(server, state);

1700

if (status == NFS_OK)

1701

return 0;

1702

nfs41_free_stateid(server, state);

1703

return nfs4_open_expired(sp, state);

1704

}

1705

#endif

1706

1690

/*

1707

/*

1691

* on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*

1708

* on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*

1692

* fields corresponding to attributes that were used to store the verifier.

1709

* fields corresponding to attributes that were used to store the verifier.

1693

* Make sure we clobber those fields in the later setattr call

1710

* Make sure we clobber those fields in the later setattr call

1694

*/

1711

*/

1695

static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)

1712

static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)

1696

{

1713

{

1697

if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&

1714

if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&

1698

!(sattr->ia_valid & ATTR_ATIME_SET))

1715

!(sattr->ia_valid & ATTR_ATIME_SET))

1699

sattr->ia_valid |= ATTR_ATIME;

1716

sattr->ia_valid |= ATTR_ATIME;

1700

1717

1701

if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&

1718

if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&

1702

!(sattr->ia_valid & ATTR_MTIME_SET))

1719

!(sattr->ia_valid & ATTR_MTIME_SET))

1703

sattr->ia_valid |= ATTR_MTIME;

1720

sattr->ia_valid |= ATTR_MTIME;

1704

}

1721

}

1705

1722

1706

/*

1723

/*

1707

* Returns a referenced nfs4_state

1724

* Returns a referenced nfs4_state

1708

*/

1725

*/

1709

static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)

1726

static int _nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)

1710

{

1727

{

1711

struct nfs4_state_owner *sp;

1728

struct nfs4_state_owner *sp;

1712

struct nfs4_state *state = NULL;

1729

struct nfs4_state *state = NULL;

1713

struct nfs_server *server = NFS_SERVER(dir);

1730

struct nfs_server *server = NFS_SERVER(dir);

1714

struct nfs4_opendata *opendata;

1731

struct nfs4_opendata *opendata;

1715

int status;

1732

int status;

1716

1733

1717

/* Protect against reboot recovery conflicts */

1734

/* Protect against reboot recovery conflicts */

1718

status = -ENOMEM;

1735

status = -ENOMEM;

1719

if (!(sp = nfs4_get_state_owner(server, cred))) {

1736

if (!(sp = nfs4_get_state_owner(server, cred))) {

1720

dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");

1737

dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");

1721

goto out_err;

1738

goto out_err;

1722

}

1739

}

1723

status = nfs4_recover_expired_lease(server);

1740

status = nfs4_recover_expired_lease(server);

1724

if (status != 0)

1741

if (status != 0)

1725

goto err_put_state_owner;

1742

goto err_put_state_owner;

1726

if (path->dentry->d_inode != NULL)

1743

if (path->dentry->d_inode != NULL)

1727

nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode);

1744

nfs4_return_incompatible_delegation(path->dentry->d_inode, fmode);

1728

status = -ENOMEM;

1745

status = -ENOMEM;

1729

opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr, GFP_KERNEL);

1746

opendata = nfs4_opendata_alloc(path, sp, fmode, flags, sattr, GFP_KERNEL);

1730

if (opendata == NULL)

1747

if (opendata == NULL)

1731

goto err_put_state_owner;

1748

goto err_put_state_owner;

1732

1749

1733

if (path->dentry->d_inode != NULL)

1750

if (path->dentry->d_inode != NULL)

1734

opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);

1751

opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);

1735

1752

1736

status = _nfs4_proc_open(opendata);

1753

status = _nfs4_proc_open(opendata);

1737

if (status != 0)

1754

if (status != 0)

1738

goto err_opendata_put;

1755

goto err_opendata_put;

1739

1756

1740

state = nfs4_opendata_to_nfs4_state(opendata);

1757

state = nfs4_opendata_to_nfs4_state(opendata);

1741

status = PTR_ERR(state);

1758

status = PTR_ERR(state);

1742

if (IS_ERR(state))

1759

if (IS_ERR(state))

1743

goto err_opendata_put;

1760

goto err_opendata_put;

1744

if (server->caps & NFS_CAP_POSIX_LOCK)

1761

if (server->caps & NFS_CAP_POSIX_LOCK)

1745

set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);

1762

set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);

1746

1763

1747

if (opendata->o_arg.open_flags & O_EXCL) {

1764

if (opendata->o_arg.open_flags & O_EXCL) {

1748

nfs4_exclusive_attrset(opendata, sattr);

1765

nfs4_exclusive_attrset(opendata, sattr);

1749

1766

1750

nfs_fattr_init(opendata->o_res.f_attr);

1767

nfs_fattr_init(opendata->o_res.f_attr);

1751

status = nfs4_do_setattr(state->inode, cred,

1768

status = nfs4_do_setattr(state->inode, cred,

1752

opendata->o_res.f_attr, sattr,

1769

opendata->o_res.f_attr, sattr,

1753

state);

1770

state);

1754

if (status == 0)

1771

if (status == 0)

1755

nfs_setattr_update_inode(state->inode, sattr);

1772

nfs_setattr_update_inode(state->inode, sattr);

1756

nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);

1773

nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);

1757

}

1774

}

1758

nfs4_opendata_put(opendata);

1775

nfs4_opendata_put(opendata);

1759

nfs4_put_state_owner(sp);

1776

nfs4_put_state_owner(sp);

1760

*res = state;

1777

*res = state;

1761

return 0;

1778

return 0;

1762

err_opendata_put:

1779

err_opendata_put:

1763

nfs4_opendata_put(opendata);

1780

nfs4_opendata_put(opendata);

1764

err_put_state_owner:

1781

err_put_state_owner:

1765

nfs4_put_state_owner(sp);

1782

nfs4_put_state_owner(sp);

1766

out_err:

1783

out_err:

1767

*res = NULL;

1784

*res = NULL;

1768

return status;

1785

return status;

1769

}

1786

}

1770

1787

1771

1788

1772

static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)

1789

static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)

1773

{

1790

{

1774

struct nfs4_exception exception = { };

1791

struct nfs4_exception exception = { };

1775

struct nfs4_state *res;

1792

struct nfs4_state *res;

1776

int status;

1793

int status;

1777

1794

1778

do {

1795

do {

1779

status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res);

1796

status = _nfs4_do_open(dir, path, fmode, flags, sattr, cred, &res);

1780

if (status == 0)

1797

if (status == 0)

1781

break;

1798

break;

1782

/* NOTE: BAD_SEQID means the server and client disagree about the

1799

/* NOTE: BAD_SEQID means the server and client disagree about the

1783

* book-keeping w.r.t. state-changing operations

1800

* book-keeping w.r.t. state-changing operations

1784

* (OPEN/CLOSE/LOCK/LOCKU...)

1801

* (OPEN/CLOSE/LOCK/LOCKU...)

1785

* It is actually a sign of a bug on the client or on the server.

1802

* It is actually a sign of a bug on the client or on the server.

1786

*

1803

*

1787

* If we receive a BAD_SEQID error in the particular case of

1804

* If we receive a BAD_SEQID error in the particular case of

1788

* doing an OPEN, we assume that nfs_increment_open_seqid() will

1805

* doing an OPEN, we assume that nfs_increment_open_seqid() will

1789

* have unhashed the old state_owner for us, and that we can

1806

* have unhashed the old state_owner for us, and that we can

1790

* therefore safely retry using a new one. We should still warn

1807

* therefore safely retry using a new one. We should still warn

1791

* the user though...

1808

* the user though...

1792

*/

1809

*/

1793

if (status == -NFS4ERR_BAD_SEQID) {

1810

if (status == -NFS4ERR_BAD_SEQID) {

1794

printk(KERN_WARNING "NFS: v4 server %s "

1811

printk(KERN_WARNING "NFS: v4 server %s "

1795

" returned a bad sequence-id error!\n",

1812

" returned a bad sequence-id error!\n",

1796

NFS_SERVER(dir)->nfs_client->cl_hostname);

1813

NFS_SERVER(dir)->nfs_client->cl_hostname);

1797

exception.retry = 1;

1814

exception.retry = 1;

1798

continue;

1815

continue;

1799

}

1816

}

1800

/*

1817

/*

1801

* BAD_STATEID on OPEN means that the server cancelled our

1818

* BAD_STATEID on OPEN means that the server cancelled our

1802

* state before it received the OPEN_CONFIRM.

1819

* state before it received the OPEN_CONFIRM.

1803

* Recover by retrying the request as per the discussion

1820

* Recover by retrying the request as per the discussion

1804

* on Page 181 of RFC3530.

1821

* on Page 181 of RFC3530.

1805

*/

1822

*/

1806

if (status == -NFS4ERR_BAD_STATEID) {

1823

if (status == -NFS4ERR_BAD_STATEID) {

1807

exception.retry = 1;

1824

exception.retry = 1;

1808

continue;

1825

continue;

1809

}

1826

}

1810

if (status == -EAGAIN) {

1827

if (status == -EAGAIN) {

1811

/* We must have found a delegation */

1828

/* We must have found a delegation */

1812

exception.retry = 1;

1829

exception.retry = 1;

1813

continue;

1830

continue;

1814

}

1831

}

1815

res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),

1832

res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),

1816

status, &exception));

1833

status, &exception));

1817

} while (exception.retry);

1834

} while (exception.retry);

1818

return res;

1835

return res;

1819

}

1836

}

1820

1837

1821

static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

1838

static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

1822

struct nfs_fattr *fattr, struct iattr *sattr,

1839

struct nfs_fattr *fattr, struct iattr *sattr,

1823

struct nfs4_state *state)

1840

struct nfs4_state *state)

1824

{

1841

{

1825

struct nfs_server *server = NFS_SERVER(inode);

1842

struct nfs_server *server = NFS_SERVER(inode);

1826

struct nfs_setattrargs arg = {

1843

struct nfs_setattrargs arg = {

1827

.fh = NFS_FH(inode),

1844

.fh = NFS_FH(inode),

1828

.iap = sattr,

1845

.iap = sattr,

1829

.server = server,

1846

.server = server,

1830

.bitmask = server->attr_bitmask,

1847

.bitmask = server->attr_bitmask,

1831

};

1848

};

1832

struct nfs_setattrres res = {

1849

struct nfs_setattrres res = {

1833

.fattr = fattr,

1850

.fattr = fattr,

1834

.server = server,

1851

.server = server,

1835

};

1852

};

1836

struct rpc_message msg = {

1853

struct rpc_message msg = {

1837

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],

1854

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],

1838

.rpc_argp = &arg,

1855

.rpc_argp = &arg,

1839

.rpc_resp = &res,

1856

.rpc_resp = &res,

1840

.rpc_cred = cred,

1857

.rpc_cred = cred,

1841

};

1858

};

1842

unsigned long timestamp = jiffies;

1859

unsigned long timestamp = jiffies;

1843

int status;

1860

int status;

1844

1861

1845

nfs_fattr_init(fattr);

1862

nfs_fattr_init(fattr);

1846

1863

1847

if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {

1864

if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {

1848

/* Use that stateid */

1865

/* Use that stateid */

1849

} else if (state != NULL) {

1866

} else if (state != NULL) {

1850

nfs4_copy_stateid(&arg.stateid, state, current->files, current->tgid);

1867

nfs4_copy_stateid(&arg.stateid, state, current->files, current->tgid);

1851

} else

1868

} else

1852

memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));

1869

memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));

1853

1870

1854

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

1871

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

1855

if (status == 0 && state != NULL)

1872

if (status == 0 && state != NULL)

1856

renew_lease(server, timestamp);

1873

renew_lease(server, timestamp);

1857

return status;

1874

return status;

1858

}

1875

}

1859

1876

1860

static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

1877

static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,

1861

struct nfs_fattr *fattr, struct iattr *sattr,

1878

struct nfs_fattr *fattr, struct iattr *sattr,

1862

struct nfs4_state *state)

1879

struct nfs4_state *state)

1863

{

1880

{

1864

struct nfs_server *server = NFS_SERVER(inode);

1881

struct nfs_server *server = NFS_SERVER(inode);

1865

struct nfs4_exception exception = { };

1882

struct nfs4_exception exception = { };

1866

int err;

1883

int err;

1867

do {

1884

do {

1868

err = nfs4_handle_exception(server,

1885

err = nfs4_handle_exception(server,

1869

_nfs4_do_setattr(inode, cred, fattr, sattr, state),

1886

_nfs4_do_setattr(inode, cred, fattr, sattr, state),

1870

&exception);

1887

&exception);

1871

} while (exception.retry);

1888

} while (exception.retry);

1872

return err;

1889

return err;

1873

}

1890

}

1874

1891

1875

struct nfs4_closedata {

1892

struct nfs4_closedata {

1876

struct path path;

1893

struct path path;

1877

struct inode *inode;

1894

struct inode *inode;

1878

struct nfs4_state *state;

1895

struct nfs4_state *state;

1879

struct nfs_closeargs arg;

1896

struct nfs_closeargs arg;

1880

struct nfs_closeres res;

1897

struct nfs_closeres res;

1881

struct nfs_fattr fattr;

1898

struct nfs_fattr fattr;

1882

unsigned long timestamp;

1899

unsigned long timestamp;

1883

bool roc;

1900

bool roc;

1884

u32 roc_barrier;

1901

u32 roc_barrier;

1885

};

1902

};

1886

1903

1887

static void nfs4_free_closedata(void *data)

1904

static void nfs4_free_closedata(void *data)

1888

{

1905

{

1889

struct nfs4_closedata *calldata = data;

1906

struct nfs4_closedata *calldata = data;

1890

struct nfs4_state_owner *sp = calldata->state->owner;

1907

struct nfs4_state_owner *sp = calldata->state->owner;

1891

1908

1892

if (calldata->roc)

1909

if (calldata->roc)

1893

pnfs_roc_release(calldata->state->inode);

1910

pnfs_roc_release(calldata->state->inode);

1894

nfs4_put_open_state(calldata->state);

1911

nfs4_put_open_state(calldata->state);

1895

nfs_free_seqid(calldata->arg.seqid);

1912

nfs_free_seqid(calldata->arg.seqid);

1896

nfs4_put_state_owner(sp);

1913

nfs4_put_state_owner(sp);

1897

path_put(&calldata->path);

1914

path_put(&calldata->path);

1898

kfree(calldata);

1915

kfree(calldata);

1899

}

1916

}

1900

1917

1901

static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,

1918

static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,

1902

fmode_t fmode)

1919

fmode_t fmode)

1903

{

1920

{

1904

spin_lock(&state->owner->so_lock);

1921

spin_lock(&state->owner->so_lock);

1905

if (!(fmode & FMODE_READ))

1922

if (!(fmode & FMODE_READ))

1906

clear_bit(NFS_O_RDONLY_STATE, &state->flags);

1923

clear_bit(NFS_O_RDONLY_STATE, &state->flags);

1907

if (!(fmode & FMODE_WRITE))

1924

if (!(fmode & FMODE_WRITE))

1908

clear_bit(NFS_O_WRONLY_STATE, &state->flags);

1925

clear_bit(NFS_O_WRONLY_STATE, &state->flags);

1909

clear_bit(NFS_O_RDWR_STATE, &state->flags);

1926

clear_bit(NFS_O_RDWR_STATE, &state->flags);

1910

spin_unlock(&state->owner->so_lock);

1927

spin_unlock(&state->owner->so_lock);

1911

}

1928

}

1912

1929

1913

static void nfs4_close_done(struct rpc_task *task, void *data)

1930

static void nfs4_close_done(struct rpc_task *task, void *data)

1914

{

1931

{

1915

struct nfs4_closedata *calldata = data;

1932

struct nfs4_closedata *calldata = data;

1916

struct nfs4_state *state = calldata->state;

1933

struct nfs4_state *state = calldata->state;

1917

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

1934

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

1918

1935

1919

if (!nfs4_sequence_done(task, &calldata->res.seq_res))

1936

if (!nfs4_sequence_done(task, &calldata->res.seq_res))

1920

return;

1937

return;

1921

/* hmm. we are done with the inode, and in the process of freeing

1938

/* hmm. we are done with the inode, and in the process of freeing

1922

* the state_owner. we keep this around to process errors

1939

* the state_owner. we keep this around to process errors

1923

*/

1940

*/

1924

switch (task->tk_status) {

1941

switch (task->tk_status) {

1925

case 0:

1942

case 0:

1926

if (calldata->roc)

1943

if (calldata->roc)

1927

pnfs_roc_set_barrier(state->inode,

1944

pnfs_roc_set_barrier(state->inode,

1928

calldata->roc_barrier);

1945

calldata->roc_barrier);

1929

nfs_set_open_stateid(state, &calldata->res.stateid, 0);

1946

nfs_set_open_stateid(state, &calldata->res.stateid, 0);

1930

renew_lease(server, calldata->timestamp);

1947

renew_lease(server, calldata->timestamp);

1931

nfs4_close_clear_stateid_flags(state,

1948

nfs4_close_clear_stateid_flags(state,

1932

calldata->arg.fmode);

1949

calldata->arg.fmode);

1933

break;

1950

break;

1934

case -NFS4ERR_STALE_STATEID:

1951

case -NFS4ERR_STALE_STATEID:

1935

case -NFS4ERR_OLD_STATEID:

1952

case -NFS4ERR_OLD_STATEID:

1936

case -NFS4ERR_BAD_STATEID:

1953

case -NFS4ERR_BAD_STATEID:

1937

case -NFS4ERR_EXPIRED:

1954

case -NFS4ERR_EXPIRED:

1938

if (calldata->arg.fmode == 0)

1955

if (calldata->arg.fmode == 0)

1939

break;

1956

break;

1940

default:

1957

default:

1941

if (nfs4_async_handle_error(task, server, state) == -EAGAIN)

1958

if (nfs4_async_handle_error(task, server, state) == -EAGAIN)

1942

rpc_restart_call_prepare(task);

1959

rpc_restart_call_prepare(task);

1943

}

1960

}

1944

nfs_release_seqid(calldata->arg.seqid);

1961

nfs_release_seqid(calldata->arg.seqid);

1945

nfs_refresh_inode(calldata->inode, calldata->res.fattr);

1962

nfs_refresh_inode(calldata->inode, calldata->res.fattr);

1946

}

1963

}

1947

1964

1948

static void nfs4_close_prepare(struct rpc_task *task, void *data)

1965

static void nfs4_close_prepare(struct rpc_task *task, void *data)

1949

{

1966

{

1950

struct nfs4_closedata *calldata = data;

1967

struct nfs4_closedata *calldata = data;

1951

struct nfs4_state *state = calldata->state;

1968

struct nfs4_state *state = calldata->state;

1952

int call_close = 0;

1969

int call_close = 0;

1953

1970

1954

if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)

1971

if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)

1955

return;

1972

return;

1956

1973

1957

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];

1974

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];

1958

calldata->arg.fmode = FMODE_READ|FMODE_WRITE;

1975

calldata->arg.fmode = FMODE_READ|FMODE_WRITE;

1959

spin_lock(&state->owner->so_lock);

1976

spin_lock(&state->owner->so_lock);

1960

/* Calculate the change in open mode */

1977

/* Calculate the change in open mode */

1961

if (state->n_rdwr == 0) {

1978

if (state->n_rdwr == 0) {

1962

if (state->n_rdonly == 0) {

1979

if (state->n_rdonly == 0) {

1963

call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);

1980

call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);

1964

call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);

1981

call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);

1965

calldata->arg.fmode &= ~FMODE_READ;

1982

calldata->arg.fmode &= ~FMODE_READ;

1966

}

1983

}

1967

if (state->n_wronly == 0) {

1984

if (state->n_wronly == 0) {

1968

call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);

1985

call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);

1969

call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);

1986

call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);

1970

calldata->arg.fmode &= ~FMODE_WRITE;

1987

calldata->arg.fmode &= ~FMODE_WRITE;

1971

}

1988

}

1972

}

1989

}

1973

spin_unlock(&state->owner->so_lock);

1990

spin_unlock(&state->owner->so_lock);

1974

1991

1975

if (!call_close) {

1992

if (!call_close) {

1976

/* Note: exit _without_ calling nfs4_close_done */

1993

/* Note: exit _without_ calling nfs4_close_done */

1977

task->tk_action = NULL;

1994

task->tk_action = NULL;

1978

return;

1995

return;

1979

}

1996

}

1980

1997

1981

if (calldata->arg.fmode == 0) {

1998

if (calldata->arg.fmode == 0) {

1982

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];

1999

task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];

1983

if (calldata->roc &&

2000

if (calldata->roc &&

1984

pnfs_roc_drain(calldata->inode, &calldata->roc_barrier)) {

2001

pnfs_roc_drain(calldata->inode, &calldata->roc_barrier)) {

1985

rpc_sleep_on(&NFS_SERVER(calldata->inode)->roc_rpcwaitq,

2002

rpc_sleep_on(&NFS_SERVER(calldata->inode)->roc_rpcwaitq,

1986

task, NULL);

2003

task, NULL);

1987

return;

2004

return;

1988

}

2005

}

1989

}

2006

}

1990

2007

1991

nfs_fattr_init(calldata->res.fattr);

2008

nfs_fattr_init(calldata->res.fattr);

1992

calldata->timestamp = jiffies;

2009

calldata->timestamp = jiffies;

1993

if (nfs4_setup_sequence(NFS_SERVER(calldata->inode),

2010

if (nfs4_setup_sequence(NFS_SERVER(calldata->inode),

1994

&calldata->arg.seq_args, &calldata->res.seq_res,

2011

&calldata->arg.seq_args, &calldata->res.seq_res,

1995

1, task))

2012

1, task))

1996

return;

2013

return;

1997

rpc_call_start(task);

2014

rpc_call_start(task);

1998

}

2015

}

1999

2016

2000

static const struct rpc_call_ops nfs4_close_ops = {

2017

static const struct rpc_call_ops nfs4_close_ops = {

2001

.rpc_call_prepare = nfs4_close_prepare,

2018

.rpc_call_prepare = nfs4_close_prepare,

2002

.rpc_call_done = nfs4_close_done,

2019

.rpc_call_done = nfs4_close_done,

2003

.rpc_release = nfs4_free_closedata,

2020

.rpc_release = nfs4_free_closedata,

2004

};

2021

};

2005

2022

2006

/*

2023

/*

2007

* It is possible for data to be read/written from a mem-mapped file

2024

* It is possible for data to be read/written from a mem-mapped file

2008

* after the sys_close call (which hits the vfs layer as a flush).

2025

* after the sys_close call (which hits the vfs layer as a flush).

2009

* This means that we can't safely call nfsv4 close on a file until

2026

* This means that we can't safely call nfsv4 close on a file until

2010

* the inode is cleared. This in turn means that we are not good

2027

* the inode is cleared. This in turn means that we are not good

2011

* NFSv4 citizens - we do not indicate to the server to update the file's

2028

* NFSv4 citizens - we do not indicate to the server to update the file's

2012

* share state even when we are done with one of the three share

2029

* share state even when we are done with one of the three share

2013

* stateid's in the inode.

2030

* stateid's in the inode.

2014

*

2031

*

2015

* NOTE: Caller must be holding the sp->so_owner semaphore!

2032

* NOTE: Caller must be holding the sp->so_owner semaphore!

2016

*/

2033

*/

2017

int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc)

2034

int nfs4_do_close(struct path *path, struct nfs4_state *state, gfp_t gfp_mask, int wait, bool roc)

2018

{

2035

{

2019

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

2036

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

2020

struct nfs4_closedata *calldata;

2037

struct nfs4_closedata *calldata;

2021

struct nfs4_state_owner *sp = state->owner;

2038

struct nfs4_state_owner *sp = state->owner;

2022

struct rpc_task *task;

2039

struct rpc_task *task;

2023

struct rpc_message msg = {

2040

struct rpc_message msg = {

2024

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],

2041

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],

2025

.rpc_cred = state->owner->so_cred,

2042

.rpc_cred = state->owner->so_cred,

2026

};

2043

};

2027

struct rpc_task_setup task_setup_data = {

2044

struct rpc_task_setup task_setup_data = {

2028

.rpc_client = server->client,

2045

.rpc_client = server->client,

2029

.rpc_message = &msg,

2046

.rpc_message = &msg,

2030

.callback_ops = &nfs4_close_ops,

2047

.callback_ops = &nfs4_close_ops,

2031

.workqueue = nfsiod_workqueue,

2048

.workqueue = nfsiod_workqueue,

2032

.flags = RPC_TASK_ASYNC,

2049

.flags = RPC_TASK_ASYNC,

2033

};

2050

};

2034

int status = -ENOMEM;

2051

int status = -ENOMEM;

2035

2052

2036

calldata = kzalloc(sizeof(*calldata), gfp_mask);

2053

calldata = kzalloc(sizeof(*calldata), gfp_mask);

2037

if (calldata == NULL)

2054

if (calldata == NULL)

2038

goto out;

2055

goto out;

2039

calldata->inode = state->inode;

2056

calldata->inode = state->inode;

2040

calldata->state = state;

2057

calldata->state = state;

2041

calldata->arg.fh = NFS_FH(state->inode);

2058

calldata->arg.fh = NFS_FH(state->inode);

2042

calldata->arg.stateid = &state->open_stateid;

2059

calldata->arg.stateid = &state->open_stateid;

2043

/* Serialization for the sequence id */

2060

/* Serialization for the sequence id */

2044

calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);

2061

calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);

2045

if (calldata->arg.seqid == NULL)

2062

if (calldata->arg.seqid == NULL)

2046

goto out_free_calldata;

2063

goto out_free_calldata;

2047

calldata->arg.fmode = 0;

2064

calldata->arg.fmode = 0;

2048

calldata->arg.bitmask = server->cache_consistency_bitmask;

2065

calldata->arg.bitmask = server->cache_consistency_bitmask;

2049

calldata->res.fattr = &calldata->fattr;

2066

calldata->res.fattr = &calldata->fattr;

2050

calldata->res.seqid = calldata->arg.seqid;

2067

calldata->res.seqid = calldata->arg.seqid;

2051

calldata->res.server = server;

2068

calldata->res.server = server;

2052

calldata->roc = roc;

2069

calldata->roc = roc;

2053

path_get(path);

2070

path_get(path);

2054

calldata->path = *path;

2071

calldata->path = *path;

2055

2072

2056

msg.rpc_argp = &calldata->arg;

2073

msg.rpc_argp = &calldata->arg;

2057

msg.rpc_resp = &calldata->res;

2074

msg.rpc_resp = &calldata->res;

2058

task_setup_data.callback_data = calldata;

2075

task_setup_data.callback_data = calldata;

2059

task = rpc_run_task(&task_setup_data);

2076

task = rpc_run_task(&task_setup_data);

2060

if (IS_ERR(task))

2077

if (IS_ERR(task))

2061

return PTR_ERR(task);

2078

return PTR_ERR(task);

2062

status = 0;

2079

status = 0;

2063

if (wait)

2080

if (wait)

2064

status = rpc_wait_for_completion_task(task);

2081

status = rpc_wait_for_completion_task(task);

2065

rpc_put_task(task);

2082

rpc_put_task(task);

2066

return status;

2083

return status;

2067

out_free_calldata:

2084

out_free_calldata:

2068

kfree(calldata);

2085

kfree(calldata);

2069

out:

2086

out:

2070

if (roc)

2087

if (roc)

2071

pnfs_roc_release(state->inode);

2088

pnfs_roc_release(state->inode);

2072

nfs4_put_open_state(state);

2089

nfs4_put_open_state(state);

2073

nfs4_put_state_owner(sp);

2090

nfs4_put_state_owner(sp);

2074

return status;

2091

return status;

2075

}

2092

}

2076

2093

2077

static struct inode *

2094

static struct inode *

2078

nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)

2095

nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)

2079

{

2096

{

2080

struct nfs4_state *state;

2097

struct nfs4_state *state;

2081

2098

2082

/* Protect against concurrent sillydeletes */

2099

/* Protect against concurrent sillydeletes */

2083

state = nfs4_do_open(dir, &ctx->path, ctx->mode, open_flags, attr, ctx->cred);

2100

state = nfs4_do_open(dir, &ctx->path, ctx->mode, open_flags, attr, ctx->cred);

2084

if (IS_ERR(state))

2101

if (IS_ERR(state))

2085

return ERR_CAST(state);

2102

return ERR_CAST(state);

2086

ctx->state = state;

2103

ctx->state = state;

2087

return igrab(state->inode);

2104

return igrab(state->inode);

2088

}

2105

}

2089

2106

2090

static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)

2107

static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)

2091

{

2108

{

2092

if (ctx->state == NULL)

2109

if (ctx->state == NULL)

2093

return;

2110

return;

2094

if (is_sync)

2111

if (is_sync)

2095

nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);

2112

nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);

2096

else

2113

else

2097

nfs4_close_state(&ctx->path, ctx->state, ctx->mode);

2114

nfs4_close_state(&ctx->path, ctx->state, ctx->mode);

2098

}

2115

}

2099

2116

2100

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

2117

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

2101

{

2118

{

2102

struct nfs4_server_caps_arg args = {

2119

struct nfs4_server_caps_arg args = {

2103

.fhandle = fhandle,

2120

.fhandle = fhandle,

2104

};

2121

};

2105

struct nfs4_server_caps_res res = {};

2122

struct nfs4_server_caps_res res = {};

2106

struct rpc_message msg = {

2123

struct rpc_message msg = {

2107

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],

2124

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],

2108

.rpc_argp = &args,

2125

.rpc_argp = &args,

2109

.rpc_resp = &res,

2126

.rpc_resp = &res,

2110

};

2127

};

2111

int status;

2128

int status;

2112

2129

2113

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

2130

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

2114

if (status == 0) {

2131

if (status == 0) {

2115

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

2132

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

2116

server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|

2133

server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|

2117

NFS_CAP_SYMLINKS|NFS_CAP_FILEID|

2134

NFS_CAP_SYMLINKS|NFS_CAP_FILEID|

2118

NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|

2135

NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|

2119

NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|

2136

NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|

2120

NFS_CAP_CTIME|NFS_CAP_MTIME);

2137

NFS_CAP_CTIME|NFS_CAP_MTIME);

2121

if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)

2138

if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)

2122

server->caps |= NFS_CAP_ACLS;

2139

server->caps |= NFS_CAP_ACLS;

2123

if (res.has_links != 0)

2140

if (res.has_links != 0)

2124

server->caps |= NFS_CAP_HARDLINKS;

2141

server->caps |= NFS_CAP_HARDLINKS;

2125

if (res.has_symlinks != 0)

2142

if (res.has_symlinks != 0)

2126

server->caps |= NFS_CAP_SYMLINKS;

2143

server->caps |= NFS_CAP_SYMLINKS;

2127

if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)

2144

if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)

2128

server->caps |= NFS_CAP_FILEID;

2145

server->caps |= NFS_CAP_FILEID;

2129

if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)

2146

if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)

2130

server->caps |= NFS_CAP_MODE;

2147

server->caps |= NFS_CAP_MODE;

2131

if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)

2148

if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)

2132

server->caps |= NFS_CAP_NLINK;

2149

server->caps |= NFS_CAP_NLINK;

2133

if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)

2150

if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)

2134

server->caps |= NFS_CAP_OWNER;

2151

server->caps |= NFS_CAP_OWNER;

2135

if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)

2152

if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)

2136

server->caps |= NFS_CAP_OWNER_GROUP;

2153

server->caps |= NFS_CAP_OWNER_GROUP;

2137

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)

2154

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)

2138

server->caps |= NFS_CAP_ATIME;

2155

server->caps |= NFS_CAP_ATIME;

2139

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)

2156

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)

2140

server->caps |= NFS_CAP_CTIME;

2157

server->caps |= NFS_CAP_CTIME;

2141

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)

2158

if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)

2142

server->caps |= NFS_CAP_MTIME;

2159

server->caps |= NFS_CAP_MTIME;

2143

2160

2144

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

2161

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

2145

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

2162

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

2146

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

2163

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

2147

server->acl_bitmask = res.acl_bitmask;

2164

server->acl_bitmask = res.acl_bitmask;

2148

}

2165

}

2149

2166

2150

return status;

2167

return status;

2151

}

2168

}

2152

2169

2153

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

2170

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

2154

{

2171

{

2155

struct nfs4_exception exception = { };

2172

struct nfs4_exception exception = { };

2156

int err;

2173

int err;

2157

do {

2174

do {

2158

err = nfs4_handle_exception(server,

2175

err = nfs4_handle_exception(server,

2159

_nfs4_server_capabilities(server, fhandle),

2176

_nfs4_server_capabilities(server, fhandle),

2160

&exception);

2177

&exception);

2161

} while (exception.retry);

2178

} while (exception.retry);

2162

return err;

2179

return err;

2163

}

2180

}

2164

2181

2165

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

2182

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

2166

struct nfs_fsinfo *info)

2183

struct nfs_fsinfo *info)

2167

{

2184

{

2168

struct nfs4_lookup_root_arg args = {

2185

struct nfs4_lookup_root_arg args = {

2169

.bitmask = nfs4_fattr_bitmap,

2186

.bitmask = nfs4_fattr_bitmap,

2170

};

2187

};

2171

struct nfs4_lookup_res res = {

2188

struct nfs4_lookup_res res = {

2172

.server = server,

2189

.server = server,

2173

.fattr = info->fattr,

2190

.fattr = info->fattr,

2174

.fh = fhandle,

2191

.fh = fhandle,

2175

};

2192

};

2176

struct rpc_message msg = {

2193

struct rpc_message msg = {

2177

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],

2194

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],

2178

.rpc_argp = &args,

2195

.rpc_argp = &args,

2179

.rpc_resp = &res,

2196

.rpc_resp = &res,

2180

};

2197

};

2181

2198

2182

nfs_fattr_init(info->fattr);

2199

nfs_fattr_init(info->fattr);

2183

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

2200

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

2184

}

2201

}

2185

2202

2186

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

2203

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

2187

struct nfs_fsinfo *info)

2204

struct nfs_fsinfo *info)

2188

{

2205

{

2189

struct nfs4_exception exception = { };

2206

struct nfs4_exception exception = { };

2190

int err;

2207

int err;

2191

do {

2208

do {

2192

err = _nfs4_lookup_root(server, fhandle, info);

2209

err = _nfs4_lookup_root(server, fhandle, info);

2193

switch (err) {

2210

switch (err) {

2194

case 0:

2211

case 0:

2195

case -NFS4ERR_WRONGSEC:

2212

case -NFS4ERR_WRONGSEC:

2196

break;

2213

break;

2197

default:

2214

default:

2198

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

2215

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

2199

}

2216

}

2200

} while (exception.retry);

2217

} while (exception.retry);

2201

return err;

2218

return err;

2202

}

2219

}

2203

2220

2204

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

2221

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

2205

struct nfs_fsinfo *info, rpc_authflavor_t flavor)

2222

struct nfs_fsinfo *info, rpc_authflavor_t flavor)

2206

{

2223

{

2207

struct rpc_auth *auth;

2224

struct rpc_auth *auth;

2208

int ret;

2225

int ret;

2209

2226

2210

auth = rpcauth_create(flavor, server->client);

2227

auth = rpcauth_create(flavor, server->client);

2211

if (!auth) {

2228

if (!auth) {

2212

ret = -EIO;

2229

ret = -EIO;

2213

goto out;

2230

goto out;

2214

}

2231

}

2215

ret = nfs4_lookup_root(server, fhandle, info);

2232

ret = nfs4_lookup_root(server, fhandle, info);

2216

out:

2233

out:

2217

return ret;

2234

return ret;

2218

}

2235

}

2219

2236

2220

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

2237

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

2221

struct nfs_fsinfo *info)

2238

struct nfs_fsinfo *info)

2222

{

2239

{

2223

int i, len, status = 0;

2240

int i, len, status = 0;

2224

rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];

2241

rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];

2225

2242

2226

len = gss_mech_list_pseudoflavors(&flav_array[0]);

2243

len = gss_mech_list_pseudoflavors(&flav_array[0]);

2227

flav_array[len] = RPC_AUTH_NULL;

2244

flav_array[len] = RPC_AUTH_NULL;

2228

len += 1;

2245

len += 1;

2229

2246

2230

for (i = 0; i < len; i++) {

2247

for (i = 0; i < len; i++) {

2231

status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);

2248

status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);

2232

if (status == -NFS4ERR_WRONGSEC || status == -EACCES)

2249

if (status == -NFS4ERR_WRONGSEC || status == -EACCES)

2233

continue;

2250

continue;

2234

break;

2251

break;

2235

}

2252

}

2236

/*

2253

/*

2237

* -EACCESS could mean that the user doesn't have correct permissions

2254

* -EACCESS could mean that the user doesn't have correct permissions

2238

* to access the mount. It could also mean that we tried to mount

2255

* to access the mount. It could also mean that we tried to mount

2239

* with a gss auth flavor, but rpc.gssd isn't running. Either way,

2256

* with a gss auth flavor, but rpc.gssd isn't running. Either way,

2240

* existing mount programs don't handle -EACCES very well so it should

2257

* existing mount programs don't handle -EACCES very well so it should

2241

* be mapped to -EPERM instead.

2258

* be mapped to -EPERM instead.

2242

*/

2259

*/

2243

if (status == -EACCES)

2260

if (status == -EACCES)

2244

status = -EPERM;

2261

status = -EPERM;

2245

return status;

2262

return status;

2246

}

2263

}

2247

2264

2248

/*

2265

/*

2249

* get the file handle for the "/" directory on the server

2266

* get the file handle for the "/" directory on the server

2250

*/

2267

*/

2251

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

2268

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

2252

struct nfs_fsinfo *info)

2269

struct nfs_fsinfo *info)

2253

{

2270

{

2254

int minor_version = server->nfs_client->cl_minorversion;

2271

int minor_version = server->nfs_client->cl_minorversion;

2255

int status = nfs4_lookup_root(server, fhandle, info);

2272

int status = nfs4_lookup_root(server, fhandle, info);

2256

if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR))

2273

if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR))

2257

/*

2274

/*

2258

* A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM

2275

* A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM

2259

* by nfs4_map_errors() as this function exits.

2276

* by nfs4_map_errors() as this function exits.

2260

*/

2277

*/

2261

status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info);

2278

status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info);

2262

if (status == 0)

2279

if (status == 0)

2263

status = nfs4_server_capabilities(server, fhandle);

2280

status = nfs4_server_capabilities(server, fhandle);

2264

if (status == 0)

2281

if (status == 0)

2265

status = nfs4_do_fsinfo(server, fhandle, info);

2282

status = nfs4_do_fsinfo(server, fhandle, info);

2266

return nfs4_map_errors(status);

2283

return nfs4_map_errors(status);

2267

}

2284

}

2268

2285

2269

static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);

2286

static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);

2270

/*

2287

/*

2271

* Get locations and (maybe) other attributes of a referral.

2288

* Get locations and (maybe) other attributes of a referral.

2272

* Note that we'll actually follow the referral later when

2289

* Note that we'll actually follow the referral later when

2273

* we detect fsid mismatch in inode revalidation

2290

* we detect fsid mismatch in inode revalidation

2274

*/

2291

*/

2275

static int nfs4_get_referral(struct inode *dir, const struct qstr *name,

2292

static int nfs4_get_referral(struct inode *dir, const struct qstr *name,

2276

struct nfs_fattr *fattr, struct nfs_fh *fhandle)

2293

struct nfs_fattr *fattr, struct nfs_fh *fhandle)

2277

{

2294

{

2278

int status = -ENOMEM;

2295

int status = -ENOMEM;

2279

struct page *page = NULL;

2296

struct page *page = NULL;

2280

struct nfs4_fs_locations *locations = NULL;

2297

struct nfs4_fs_locations *locations = NULL;

2281

2298

2282

page = alloc_page(GFP_KERNEL);

2299

page = alloc_page(GFP_KERNEL);

2283

if (page == NULL)

2300

if (page == NULL)

2284

goto out;

2301

goto out;

2285

locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);

2302

locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);

2286

if (locations == NULL)

2303

if (locations == NULL)

2287

goto out;

2304

goto out;

2288

2305

2289

status = nfs4_proc_fs_locations(dir, name, locations, page);

2306

status = nfs4_proc_fs_locations(dir, name, locations, page);

2290

if (status != 0)

2307

if (status != 0)

2291

goto out;

2308

goto out;

2292

/* Make sure server returned a different fsid for the referral */

2309

/* Make sure server returned a different fsid for the referral */

2293

if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {

2310

if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {

2294

dprintk("%s: server did not return a different fsid for"

2311

dprintk("%s: server did not return a different fsid for"

2295

" a referral at %s\n", __func__, name->name);

2312

" a referral at %s\n", __func__, name->name);

2296

status = -EIO;

2313

status = -EIO;

2297

goto out;

2314

goto out;

2298

}

2315

}

2299

/* Fixup attributes for the nfs_lookup() call to nfs_fhget() */

2316

/* Fixup attributes for the nfs_lookup() call to nfs_fhget() */

2300

nfs_fixup_referral_attributes(&locations->fattr);

2317

nfs_fixup_referral_attributes(&locations->fattr);

2301

2318

2302

/* replace the lookup nfs_fattr with the locations nfs_fattr */

2319

/* replace the lookup nfs_fattr with the locations nfs_fattr */

2303

memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));

2320

memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));

2304

memset(fhandle, 0, sizeof(struct nfs_fh));

2321

memset(fhandle, 0, sizeof(struct nfs_fh));

2305

out:

2322

out:

2306

if (page)

2323

if (page)

2307

__free_page(page);

2324

__free_page(page);

2308

kfree(locations);

2325

kfree(locations);

2309

return status;

2326

return status;

2310

}

2327

}

2311

2328

2312

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2329

static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2313

{

2330

{

2314

struct nfs4_getattr_arg args = {

2331

struct nfs4_getattr_arg args = {

2315

.fh = fhandle,

2332

.fh = fhandle,

2316

.bitmask = server->attr_bitmask,

2333

.bitmask = server->attr_bitmask,

2317

};

2334

};

2318

struct nfs4_getattr_res res = {

2335

struct nfs4_getattr_res res = {

2319

.fattr = fattr,

2336

.fattr = fattr,

2320

.server = server,

2337

.server = server,

2321

};

2338

};

2322

struct rpc_message msg = {

2339

struct rpc_message msg = {

2323

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],

2340

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],

2324

.rpc_argp = &args,

2341

.rpc_argp = &args,

2325

.rpc_resp = &res,

2342

.rpc_resp = &res,

2326

};

2343

};

2327

2344

2328

nfs_fattr_init(fattr);

2345

nfs_fattr_init(fattr);

2329

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

2346

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

2330

}

2347

}

2331

2348

2332

static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2349

static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2333

{

2350

{

2334

struct nfs4_exception exception = { };

2351

struct nfs4_exception exception = { };

2335

int err;

2352

int err;

2336

do {

2353

do {

2337

err = nfs4_handle_exception(server,

2354

err = nfs4_handle_exception(server,

2338

_nfs4_proc_getattr(server, fhandle, fattr),

2355

_nfs4_proc_getattr(server, fhandle, fattr),

2339

&exception);

2356

&exception);

2340

} while (exception.retry);

2357

} while (exception.retry);

2341

return err;

2358

return err;

2342

}

2359

}

2343

2360

2344

/*

2361

/*

2345

* The file is not closed if it is opened due to the a request to change

2362

* The file is not closed if it is opened due to the a request to change

2346

* the size of the file. The open call will not be needed once the

2363

* the size of the file. The open call will not be needed once the

2347

* VFS layer lookup-intents are implemented.

2364

* VFS layer lookup-intents are implemented.

2348

*

2365

*

2349

* Close is called when the inode is destroyed.

2366

* Close is called when the inode is destroyed.

2350

* If we haven't opened the file for O_WRONLY, we

2367

* If we haven't opened the file for O_WRONLY, we

2351

* need to in the size_change case to obtain a stateid.

2368

* need to in the size_change case to obtain a stateid.

2352

*

2369

*

2353

* Got race?

2370

* Got race?

2354

* Because OPEN is always done by name in nfsv4, it is

2371

* Because OPEN is always done by name in nfsv4, it is

2355

* possible that we opened a different file by the same

2372

* possible that we opened a different file by the same

2356

* name. We can recognize this race condition, but we

2373

* name. We can recognize this race condition, but we

2357

* can't do anything about it besides returning an error.

2374

* can't do anything about it besides returning an error.

2358

*

2375

*

2359

* This will be fixed with VFS changes (lookup-intent).

2376

* This will be fixed with VFS changes (lookup-intent).

2360

*/

2377

*/

2361

static int

2378

static int

2362

nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,

2379

nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,

2363

struct iattr *sattr)

2380

struct iattr *sattr)

2364

{

2381

{

2365

struct inode *inode = dentry->d_inode;

2382

struct inode *inode = dentry->d_inode;

2366

struct rpc_cred *cred = NULL;

2383

struct rpc_cred *cred = NULL;

2367

struct nfs4_state *state = NULL;

2384

struct nfs4_state *state = NULL;

2368

int status;

2385

int status;

2369

2386

2370

if (pnfs_ld_layoutret_on_setattr(inode))

2387

if (pnfs_ld_layoutret_on_setattr(inode))

2371

pnfs_return_layout(inode);

2388

pnfs_return_layout(inode);

2372

2389

2373

nfs_fattr_init(fattr);

2390

nfs_fattr_init(fattr);

2374

2391

2375

/* Search for an existing open(O_WRITE) file */

2392

/* Search for an existing open(O_WRITE) file */

2376

if (sattr->ia_valid & ATTR_FILE) {

2393

if (sattr->ia_valid & ATTR_FILE) {

2377

struct nfs_open_context *ctx;

2394

struct nfs_open_context *ctx;

2378

2395

2379

ctx = nfs_file_open_context(sattr->ia_file);

2396

ctx = nfs_file_open_context(sattr->ia_file);

2380

if (ctx) {

2397

if (ctx) {

2381

cred = ctx->cred;

2398

cred = ctx->cred;

2382

state = ctx->state;

2399

state = ctx->state;

2383

}

2400

}

2384

}

2401

}

2385

2402

2386

status = nfs4_do_setattr(inode, cred, fattr, sattr, state);

2403

status = nfs4_do_setattr(inode, cred, fattr, sattr, state);

2387

if (status == 0)

2404

if (status == 0)

2388

nfs_setattr_update_inode(inode, sattr);

2405

nfs_setattr_update_inode(inode, sattr);

2389

return status;

2406

return status;

2390

}

2407

}

2391

2408

2392

static int _nfs4_proc_lookupfh(struct rpc_clnt *clnt, struct nfs_server *server,

2409

static int _nfs4_proc_lookupfh(struct rpc_clnt *clnt, struct nfs_server *server,

2393

const struct nfs_fh *dirfh, const struct qstr *name,

2410

const struct nfs_fh *dirfh, const struct qstr *name,

2394

struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2411

struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2395

{

2412

{

2396

int status;

2413

int status;

2397

struct nfs4_lookup_arg args = {

2414

struct nfs4_lookup_arg args = {

2398

.bitmask = server->attr_bitmask,

2415

.bitmask = server->attr_bitmask,

2399

.dir_fh = dirfh,

2416

.dir_fh = dirfh,

2400

.name = name,

2417

.name = name,

2401

};

2418

};

2402

struct nfs4_lookup_res res = {

2419

struct nfs4_lookup_res res = {

2403

.server = server,

2420

.server = server,

2404

.fattr = fattr,

2421

.fattr = fattr,

2405

.fh = fhandle,

2422

.fh = fhandle,

2406

};

2423

};

2407

struct rpc_message msg = {

2424

struct rpc_message msg = {

2408

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],

2425

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],

2409

.rpc_argp = &args,

2426

.rpc_argp = &args,

2410

.rpc_resp = &res,

2427

.rpc_resp = &res,

2411

};

2428

};

2412

2429

2413

nfs_fattr_init(fattr);

2430

nfs_fattr_init(fattr);

2414

2431

2415

dprintk("NFS call lookupfh %s\n", name->name);

2432

dprintk("NFS call lookupfh %s\n", name->name);

2416

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

2433

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

2417

dprintk("NFS reply lookupfh: %d\n", status);

2434

dprintk("NFS reply lookupfh: %d\n", status);

2418

return status;

2435

return status;

2419

}

2436

}

2420

2437

2421

static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,

2438

static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,

2422

struct qstr *name, struct nfs_fh *fhandle,

2439

struct qstr *name, struct nfs_fh *fhandle,

2423

struct nfs_fattr *fattr)

2440

struct nfs_fattr *fattr)

2424

{

2441

{

2425

struct nfs4_exception exception = { };

2442

struct nfs4_exception exception = { };

2426

int err;

2443

int err;

2427

do {

2444

do {

2428

err = _nfs4_proc_lookupfh(server->client, server, dirfh, name, fhandle, fattr);

2445

err = _nfs4_proc_lookupfh(server->client, server, dirfh, name, fhandle, fattr);

2429

/* FIXME: !!!! */

2446

/* FIXME: !!!! */

2430

if (err == -NFS4ERR_MOVED) {

2447

if (err == -NFS4ERR_MOVED) {

2431

err = -EREMOTE;

2448

err = -EREMOTE;

2432

break;

2449

break;

2433

}

2450

}

2434

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

2451

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

2435

} while (exception.retry);

2452

} while (exception.retry);

2436

return err;

2453

return err;

2437

}

2454

}

2438

2455

2439

static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,

2456

static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,

2440

const struct qstr *name, struct nfs_fh *fhandle,

2457

const struct qstr *name, struct nfs_fh *fhandle,

2441

struct nfs_fattr *fattr)

2458

struct nfs_fattr *fattr)

2442

{

2459

{

2443

int status;

2460

int status;

2444

2461

2445

dprintk("NFS call lookup %s\n", name->name);

2462

dprintk("NFS call lookup %s\n", name->name);

2446

status = _nfs4_proc_lookupfh(clnt, NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);

2463

status = _nfs4_proc_lookupfh(clnt, NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);

2447

if (status == -NFS4ERR_MOVED)

2464

if (status == -NFS4ERR_MOVED)

2448

status = nfs4_get_referral(dir, name, fattr, fhandle);

2465

status = nfs4_get_referral(dir, name, fattr, fhandle);

2449

dprintk("NFS reply lookup: %d\n", status);

2466

dprintk("NFS reply lookup: %d\n", status);

2450

return status;

2467

return status;

2451

}

2468

}

2452

2469

2453

void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr, struct nfs_fh *fh)

2470

void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr, struct nfs_fh *fh)

2454

{

2471

{

2455

memset(fh, 0, sizeof(struct nfs_fh));

2472

memset(fh, 0, sizeof(struct nfs_fh));

2456

fattr->fsid.major = 1;

2473

fattr->fsid.major = 1;

2457

fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |

2474

fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |

2458

NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_FSID | NFS_ATTR_FATTR_MOUNTPOINT;

2475

NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_FSID | NFS_ATTR_FATTR_MOUNTPOINT;

2459

fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;

2476

fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;

2460

fattr->nlink = 2;

2477

fattr->nlink = 2;

2461

}

2478

}

2462

2479

2463

static int nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name,

2480

static int nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name,

2464

struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2481

struct nfs_fh *fhandle, struct nfs_fattr *fattr)

2465

{

2482

{

2466

struct nfs4_exception exception = { };

2483

struct nfs4_exception exception = { };

2467

int err;

2484

int err;

2468

do {

2485

do {

2469

err = nfs4_handle_exception(NFS_SERVER(dir),

2486

err = nfs4_handle_exception(NFS_SERVER(dir),

2470

_nfs4_proc_lookup(clnt, dir, name, fhandle, fattr),

2487

_nfs4_proc_lookup(clnt, dir, name, fhandle, fattr),

2471

&exception);

2488

&exception);

2472

if (err == -EPERM)

2489

if (err == -EPERM)

2473

nfs_fixup_secinfo_attributes(fattr, fhandle);

2490

nfs_fixup_secinfo_attributes(fattr, fhandle);

2474

} while (exception.retry);

2491

} while (exception.retry);

2475

return err;

2492

return err;

2476

}

2493

}

2477

2494

2478

static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)

2495

static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)

2479

{

2496

{

2480

struct nfs_server *server = NFS_SERVER(inode);

2497

struct nfs_server *server = NFS_SERVER(inode);

2481

struct nfs4_accessargs args = {

2498

struct nfs4_accessargs args = {

2482

.fh = NFS_FH(inode),

2499

.fh = NFS_FH(inode),

2483

.bitmask = server->attr_bitmask,

2500

.bitmask = server->attr_bitmask,

2484

};

2501

};

2485

struct nfs4_accessres res = {

2502

struct nfs4_accessres res = {

2486

.server = server,

2503

.server = server,

2487

};

2504

};

2488

struct rpc_message msg = {

2505

struct rpc_message msg = {

2489

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],

2506

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],

2490

.rpc_argp = &args,

2507

.rpc_argp = &args,

2491

.rpc_resp = &res,

2508

.rpc_resp = &res,

2492

.rpc_cred = entry->cred,

2509

.rpc_cred = entry->cred,

2493

};

2510

};

2494

int mode = entry->mask;

2511

int mode = entry->mask;

2495

int status;

2512

int status;

2496

2513

2497

/*

2514

/*

2498

* Determine which access bits we want to ask for...

2515

* Determine which access bits we want to ask for...

2499

*/

2516

*/

2500

if (mode & MAY_READ)

2517

if (mode & MAY_READ)

2501

args.access |= NFS4_ACCESS_READ;

2518

args.access |= NFS4_ACCESS_READ;

2502

if (S_ISDIR(inode->i_mode)) {

2519

if (S_ISDIR(inode->i_mode)) {

2503

if (mode & MAY_WRITE)

2520

if (mode & MAY_WRITE)

2504

args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;

2521

args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;

2505

if (mode & MAY_EXEC)

2522

if (mode & MAY_EXEC)

2506

args.access |= NFS4_ACCESS_LOOKUP;

2523

args.access |= NFS4_ACCESS_LOOKUP;

2507

} else {

2524

} else {

2508

if (mode & MAY_WRITE)

2525

if (mode & MAY_WRITE)

2509

args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;

2526

args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;

2510

if (mode & MAY_EXEC)

2527

if (mode & MAY_EXEC)

2511

args.access |= NFS4_ACCESS_EXECUTE;

2528

args.access |= NFS4_ACCESS_EXECUTE;

2512

}

2529

}

2513

2530

2514

res.fattr = nfs_alloc_fattr();

2531

res.fattr = nfs_alloc_fattr();

2515

if (res.fattr == NULL)

2532

if (res.fattr == NULL)

2516

return -ENOMEM;

2533

return -ENOMEM;

2517

2534

2518

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

2535

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

2519

if (!status) {

2536

if (!status) {

2520

entry->mask = 0;

2537

entry->mask = 0;

2521

if (res.access & NFS4_ACCESS_READ)

2538

if (res.access & NFS4_ACCESS_READ)

2522

entry->mask |= MAY_READ;

2539

entry->mask |= MAY_READ;

2523

if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))

2540

if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))

2524

entry->mask |= MAY_WRITE;

2541

entry->mask |= MAY_WRITE;

2525

if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))

2542

if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))

2526

entry->mask |= MAY_EXEC;

2543

entry->mask |= MAY_EXEC;

2527

nfs_refresh_inode(inode, res.fattr);

2544

nfs_refresh_inode(inode, res.fattr);

2528

}

2545

}

2529

nfs_free_fattr(res.fattr);

2546

nfs_free_fattr(res.fattr);

2530

return status;

2547

return status;

2531

}

2548

}

2532

2549

2533

static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)

2550

static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)

2534

{

2551

{

2535

struct nfs4_exception exception = { };

2552

struct nfs4_exception exception = { };

2536

int err;

2553

int err;

2537

do {

2554

do {

2538

err = nfs4_handle_exception(NFS_SERVER(inode),

2555

err = nfs4_handle_exception(NFS_SERVER(inode),

2539

_nfs4_proc_access(inode, entry),

2556

_nfs4_proc_access(inode, entry),

2540

&exception);

2557

&exception);

2541

} while (exception.retry);

2558

} while (exception.retry);

2542

return err;

2559

return err;

2543

}

2560

}

2544

2561

2545

/*

2562

/*

2546

* TODO: For the time being, we don't try to get any attributes

2563

* TODO: For the time being, we don't try to get any attributes

2547

* along with any of the zero-copy operations READ, READDIR,

2564

* along with any of the zero-copy operations READ, READDIR,

2548

* READLINK, WRITE.

2565

* READLINK, WRITE.

2549

*

2566

*

2550

* In the case of the first three, we want to put the GETATTR

2567

* In the case of the first three, we want to put the GETATTR

2551

* after the read-type operation -- this is because it is hard

2568

* after the read-type operation -- this is because it is hard

2552

* to predict the length of a GETATTR response in v4, and thus

2569

* to predict the length of a GETATTR response in v4, and thus

2553

* align the READ data correctly. This means that the GETATTR

2570

* align the READ data correctly. This means that the GETATTR

2554

* may end up partially falling into the page cache, and we should

2571

* may end up partially falling into the page cache, and we should

2555

* shift it into the 'tail' of the xdr_buf before processing.

2572

* shift it into the 'tail' of the xdr_buf before processing.

2556

* To do this efficiently, we need to know the total length

2573

* To do this efficiently, we need to know the total length

2557

* of data received, which doesn't seem to be available outside

2574

* of data received, which doesn't seem to be available outside

2558

* of the RPC layer.

2575

* of the RPC layer.

2559

*

2576

*

2560

* In the case of WRITE, we also want to put the GETATTR after

2577

* In the case of WRITE, we also want to put the GETATTR after

2561

* the operation -- in this case because we want to make sure

2578

* the operation -- in this case because we want to make sure

2562

* we get the post-operation mtime and size. This means that

2579

* we get the post-operation mtime and size. This means that

2563

* we can't use xdr_encode_pages() as written: we need a variant

2580

* we can't use xdr_encode_pages() as written: we need a variant

2564

* of it which would leave room in the 'tail' iovec.

2581

* of it which would leave room in the 'tail' iovec.

2565

*

2582

*

2566

* Both of these changes to the XDR layer would in fact be quite

2583

* Both of these changes to the XDR layer would in fact be quite

2567

* minor, but I decided to leave them for a subsequent patch.

2584

* minor, but I decided to leave them for a subsequent patch.

2568

*/

2585

*/

2569

static int _nfs4_proc_readlink(struct inode *inode, struct page *page,

2586

static int _nfs4_proc_readlink(struct inode *inode, struct page *page,

2570

unsigned int pgbase, unsigned int pglen)

2587

unsigned int pgbase, unsigned int pglen)

2571

{

2588

{

2572

struct nfs4_readlink args = {

2589

struct nfs4_readlink args = {

2573

.fh = NFS_FH(inode),

2590

.fh = NFS_FH(inode),

2574

.pgbase = pgbase,

2591

.pgbase = pgbase,

2575

.pglen = pglen,

2592

.pglen = pglen,

2576

.pages = &page,

2593

.pages = &page,

2577

};

2594

};

2578

struct nfs4_readlink_res res;

2595

struct nfs4_readlink_res res;

2579

struct rpc_message msg = {

2596

struct rpc_message msg = {

2580

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],

2597

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],

2581

.rpc_argp = &args,

2598

.rpc_argp = &args,

2582

.rpc_resp = &res,

2599

.rpc_resp = &res,

2583

};

2600

};

2584

2601

2585

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

2602

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

2586

}

2603

}

2587

2604

2588

static int nfs4_proc_readlink(struct inode *inode, struct page *page,

2605

static int nfs4_proc_readlink(struct inode *inode, struct page *page,

2589

unsigned int pgbase, unsigned int pglen)

2606

unsigned int pgbase, unsigned int pglen)

2590

{

2607

{

2591

struct nfs4_exception exception = { };

2608

struct nfs4_exception exception = { };

2592

int err;

2609

int err;

2593

do {

2610

do {

2594

err = nfs4_handle_exception(NFS_SERVER(inode),

2611

err = nfs4_handle_exception(NFS_SERVER(inode),

2595

_nfs4_proc_readlink(inode, page, pgbase, pglen),

2612

_nfs4_proc_readlink(inode, page, pgbase, pglen),

2596

&exception);

2613

&exception);

2597

} while (exception.retry);

2614

} while (exception.retry);

2598

return err;

2615

return err;

2599

}

2616

}

2600

2617

2601

/*

2618

/*

2602

* Got race?

2619

* Got race?

2603

* We will need to arrange for the VFS layer to provide an atomic open.

2620

* We will need to arrange for the VFS layer to provide an atomic open.

2604

* Until then, this create/open method is prone to inefficiency and race

2621

* Until then, this create/open method is prone to inefficiency and race

2605

* conditions due to the lookup, create, and open VFS calls from sys_open()

2622

* conditions due to the lookup, create, and open VFS calls from sys_open()

2606

* placed on the wire.

2623

* placed on the wire.

2607

*

2624

*

2608

* Given the above sorry state of affairs, I'm simply sending an OPEN.

2625

* Given the above sorry state of affairs, I'm simply sending an OPEN.

2609

* The file will be opened again in the subsequent VFS open call

2626

* The file will be opened again in the subsequent VFS open call

2610

* (nfs4_proc_file_open).

2627

* (nfs4_proc_file_open).

2611

*

2628

*

2612

* The open for read will just hang around to be used by any process that

2629

* The open for read will just hang around to be used by any process that

2613

* opens the file O_RDONLY. This will all be resolved with the VFS changes.

2630

* opens the file O_RDONLY. This will all be resolved with the VFS changes.

2614

*/

2631

*/

2615

2632

2616

static int

2633

static int

2617

nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,

2634

nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,

2618

int flags, struct nfs_open_context *ctx)

2635

int flags, struct nfs_open_context *ctx)

2619

{

2636

{

2620

struct path my_path = {

2637

struct path my_path = {

2621

.dentry = dentry,

2638

.dentry = dentry,

2622

};

2639

};

2623

struct path *path = &my_path;

2640

struct path *path = &my_path;

2624

struct nfs4_state *state;

2641

struct nfs4_state *state;

2625

struct rpc_cred *cred = NULL;

2642

struct rpc_cred *cred = NULL;

2626

fmode_t fmode = 0;

2643

fmode_t fmode = 0;

2627

int status = 0;

2644

int status = 0;

2628

2645

2629

if (ctx != NULL) {

2646

if (ctx != NULL) {

2630

cred = ctx->cred;

2647

cred = ctx->cred;

2631

path = &ctx->path;

2648

path = &ctx->path;

2632

fmode = ctx->mode;

2649

fmode = ctx->mode;

2633

}

2650

}

2634

sattr->ia_mode &= ~current_umask();

2651

sattr->ia_mode &= ~current_umask();

2635

state = nfs4_do_open(dir, path, fmode, flags, sattr, cred);

2652

state = nfs4_do_open(dir, path, fmode, flags, sattr, cred);

2636

d_drop(dentry);

2653

d_drop(dentry);

2637

if (IS_ERR(state)) {

2654

if (IS_ERR(state)) {

2638

status = PTR_ERR(state);

2655

status = PTR_ERR(state);

2639

goto out;

2656

goto out;

2640

}

2657

}

2641

d_add(dentry, igrab(state->inode));

2658

d_add(dentry, igrab(state->inode));

2642

nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

2659

nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

2643

if (ctx != NULL)

2660

if (ctx != NULL)

2644

ctx->state = state;

2661

ctx->state = state;

2645

else

2662

else

2646

nfs4_close_sync(path, state, fmode);

2663

nfs4_close_sync(path, state, fmode);

2647

out:

2664

out:

2648

return status;

2665

return status;

2649

}

2666

}

2650

2667

2651

static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)

2668

static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)

2652

{

2669

{

2653

struct nfs_server *server = NFS_SERVER(dir);

2670

struct nfs_server *server = NFS_SERVER(dir);

2654

struct nfs_removeargs args = {

2671

struct nfs_removeargs args = {

2655

.fh = NFS_FH(dir),

2672

.fh = NFS_FH(dir),

2656

.name.len = name->len,

2673

.name.len = name->len,

2657

.name.name = name->name,

2674

.name.name = name->name,

2658

.bitmask = server->attr_bitmask,

2675

.bitmask = server->attr_bitmask,

2659

};

2676

};

2660

struct nfs_removeres res = {

2677

struct nfs_removeres res = {

2661

.server = server,

2678

.server = server,

2662

};

2679

};

2663

struct rpc_message msg = {

2680

struct rpc_message msg = {

2664

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],

2681

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],

2665

.rpc_argp = &args,

2682

.rpc_argp = &args,

2666

.rpc_resp = &res,

2683

.rpc_resp = &res,

2667

};

2684

};

2668

int status = -ENOMEM;

2685

int status = -ENOMEM;

2669

2686

2670

res.dir_attr = nfs_alloc_fattr();

2687

res.dir_attr = nfs_alloc_fattr();

2671

if (res.dir_attr == NULL)

2688

if (res.dir_attr == NULL)

2672

goto out;

2689

goto out;

2673

2690

2674

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

2691

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

2675

if (status == 0) {

2692

if (status == 0) {

2676

update_changeattr(dir, &res.cinfo);

2693

update_changeattr(dir, &res.cinfo);

2677

nfs_post_op_update_inode(dir, res.dir_attr);

2694

nfs_post_op_update_inode(dir, res.dir_attr);

2678

}

2695

}

2679

nfs_free_fattr(res.dir_attr);

2696

nfs_free_fattr(res.dir_attr);

2680

out:

2697

out:

2681

return status;

2698

return status;

2682

}

2699

}

2683

2700

2684

static int nfs4_proc_remove(struct inode *dir, struct qstr *name)

2701

static int nfs4_proc_remove(struct inode *dir, struct qstr *name)

2685

{

2702

{

2686

struct nfs4_exception exception = { };

2703

struct nfs4_exception exception = { };

2687

int err;

2704

int err;

2688

do {

2705

do {

2689

err = nfs4_handle_exception(NFS_SERVER(dir),

2706

err = nfs4_handle_exception(NFS_SERVER(dir),

2690

_nfs4_proc_remove(dir, name),

2707

_nfs4_proc_remove(dir, name),

2691

&exception);

2708

&exception);

2692

} while (exception.retry);

2709

} while (exception.retry);

2693

return err;

2710

return err;

2694

}

2711

}

2695

2712

2696

static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)

2713

static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)

2697

{

2714

{

2698

struct nfs_server *server = NFS_SERVER(dir);

2715

struct nfs_server *server = NFS_SERVER(dir);

2699

struct nfs_removeargs *args = msg->rpc_argp;

2716

struct nfs_removeargs *args = msg->rpc_argp;

2700

struct nfs_removeres *res = msg->rpc_resp;

2717

struct nfs_removeres *res = msg->rpc_resp;

2701

2718

2702

args->bitmask = server->cache_consistency_bitmask;

2719

args->bitmask = server->cache_consistency_bitmask;

2703

res->server = server;

2720

res->server = server;

2704

res->seq_res.sr_slot = NULL;

2721

res->seq_res.sr_slot = NULL;

2705

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];

2722

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];

2706

}

2723

}

2707

2724

2708

static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)

2725

static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)

2709

{

2726

{

2710

struct nfs_removeres *res = task->tk_msg.rpc_resp;

2727

struct nfs_removeres *res = task->tk_msg.rpc_resp;

2711

2728

2712

if (!nfs4_sequence_done(task, &res->seq_res))

2729

if (!nfs4_sequence_done(task, &res->seq_res))

2713

return 0;

2730

return 0;

2714

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

2731

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

2715

return 0;

2732

return 0;

2716

update_changeattr(dir, &res->cinfo);

2733

update_changeattr(dir, &res->cinfo);

2717

nfs_post_op_update_inode(dir, res->dir_attr);

2734

nfs_post_op_update_inode(dir, res->dir_attr);

2718

return 1;

2735

return 1;

2719

}

2736

}

2720

2737

2721

static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)

2738

static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)

2722

{

2739

{

2723

struct nfs_server *server = NFS_SERVER(dir);

2740

struct nfs_server *server = NFS_SERVER(dir);

2724

struct nfs_renameargs *arg = msg->rpc_argp;

2741

struct nfs_renameargs *arg = msg->rpc_argp;

2725

struct nfs_renameres *res = msg->rpc_resp;

2742

struct nfs_renameres *res = msg->rpc_resp;

2726

2743

2727

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];

2744

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];

2728

arg->bitmask = server->attr_bitmask;

2745

arg->bitmask = server->attr_bitmask;

2729

res->server = server;

2746

res->server = server;

2730

}

2747

}

2731

2748

2732

static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,

2749

static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,

2733

struct inode *new_dir)

2750

struct inode *new_dir)

2734

{

2751

{

2735

struct nfs_renameres *res = task->tk_msg.rpc_resp;

2752

struct nfs_renameres *res = task->tk_msg.rpc_resp;

2736

2753

2737

if (!nfs4_sequence_done(task, &res->seq_res))

2754

if (!nfs4_sequence_done(task, &res->seq_res))

2738

return 0;

2755

return 0;

2739

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

2756

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

2740

return 0;

2757

return 0;

2741

2758

2742

update_changeattr(old_dir, &res->old_cinfo);

2759

update_changeattr(old_dir, &res->old_cinfo);

2743

nfs_post_op_update_inode(old_dir, res->old_fattr);

2760

nfs_post_op_update_inode(old_dir, res->old_fattr);

2744

update_changeattr(new_dir, &res->new_cinfo);

2761

update_changeattr(new_dir, &res->new_cinfo);

2745

nfs_post_op_update_inode(new_dir, res->new_fattr);

2762

nfs_post_op_update_inode(new_dir, res->new_fattr);

2746

return 1;

2763

return 1;

2747

}

2764

}

2748

2765

2749

static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,

2766

static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,

2750

struct inode *new_dir, struct qstr *new_name)

2767

struct inode *new_dir, struct qstr *new_name)

2751

{

2768

{

2752

struct nfs_server *server = NFS_SERVER(old_dir);

2769

struct nfs_server *server = NFS_SERVER(old_dir);

2753

struct nfs_renameargs arg = {

2770

struct nfs_renameargs arg = {

2754

.old_dir = NFS_FH(old_dir),

2771

.old_dir = NFS_FH(old_dir),

2755

.new_dir = NFS_FH(new_dir),

2772

.new_dir = NFS_FH(new_dir),

2756

.old_name = old_name,

2773

.old_name = old_name,

2757

.new_name = new_name,

2774

.new_name = new_name,

2758

.bitmask = server->attr_bitmask,

2775

.bitmask = server->attr_bitmask,

2759

};

2776

};

2760

struct nfs_renameres res = {

2777

struct nfs_renameres res = {

2761

.server = server,

2778

.server = server,

2762

};

2779

};

2763

struct rpc_message msg = {

2780

struct rpc_message msg = {

2764

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],

2781

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],

2765

.rpc_argp = &arg,

2782

.rpc_argp = &arg,

2766

.rpc_resp = &res,

2783

.rpc_resp = &res,

2767

};

2784

};

2768

int status = -ENOMEM;

2785

int status = -ENOMEM;

2769

2786

2770

res.old_fattr = nfs_alloc_fattr();

2787

res.old_fattr = nfs_alloc_fattr();

2771

res.new_fattr = nfs_alloc_fattr();

2788

res.new_fattr = nfs_alloc_fattr();

2772

if (res.old_fattr == NULL || res.new_fattr == NULL)

2789

if (res.old_fattr == NULL || res.new_fattr == NULL)

2773

goto out;

2790

goto out;

2774

2791

2775

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

2792

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

2776

if (!status) {

2793

if (!status) {

2777

update_changeattr(old_dir, &res.old_cinfo);

2794

update_changeattr(old_dir, &res.old_cinfo);

2778

nfs_post_op_update_inode(old_dir, res.old_fattr);

2795

nfs_post_op_update_inode(old_dir, res.old_fattr);

2779

update_changeattr(new_dir, &res.new_cinfo);

2796

update_changeattr(new_dir, &res.new_cinfo);

2780

nfs_post_op_update_inode(new_dir, res.new_fattr);

2797

nfs_post_op_update_inode(new_dir, res.new_fattr);

2781

}

2798

}

2782

out:

2799

out:

2783

nfs_free_fattr(res.new_fattr);

2800

nfs_free_fattr(res.new_fattr);

2784

nfs_free_fattr(res.old_fattr);

2801

nfs_free_fattr(res.old_fattr);

2785

return status;

2802

return status;

2786

}

2803

}

2787

2804

2788

static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,

2805

static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,

2789

struct inode *new_dir, struct qstr *new_name)

2806

struct inode *new_dir, struct qstr *new_name)

2790

{

2807

{

2791

struct nfs4_exception exception = { };

2808

struct nfs4_exception exception = { };

2792

int err;

2809

int err;

2793

do {

2810

do {

2794

err = nfs4_handle_exception(NFS_SERVER(old_dir),

2811

err = nfs4_handle_exception(NFS_SERVER(old_dir),

2795

_nfs4_proc_rename(old_dir, old_name,

2812

_nfs4_proc_rename(old_dir, old_name,

2796

new_dir, new_name),

2813

new_dir, new_name),

2797

&exception);

2814

&exception);

2798

} while (exception.retry);

2815

} while (exception.retry);

2799

return err;

2816

return err;

2800

}

2817

}

2801

2818

2802

static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)

2819

static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)

2803

{

2820

{

2804

struct nfs_server *server = NFS_SERVER(inode);

2821

struct nfs_server *server = NFS_SERVER(inode);

2805

struct nfs4_link_arg arg = {

2822

struct nfs4_link_arg arg = {

2806

.fh = NFS_FH(inode),

2823

.fh = NFS_FH(inode),

2807

.dir_fh = NFS_FH(dir),

2824

.dir_fh = NFS_FH(dir),

2808

.name = name,

2825

.name = name,

2809

.bitmask = server->attr_bitmask,

2826

.bitmask = server->attr_bitmask,

2810

};

2827

};

2811

struct nfs4_link_res res = {

2828

struct nfs4_link_res res = {

2812

.server = server,

2829

.server = server,

2813

};

2830

};

2814

struct rpc_message msg = {

2831

struct rpc_message msg = {

2815

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],

2832

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],

2816

.rpc_argp = &arg,

2833

.rpc_argp = &arg,

2817

.rpc_resp = &res,

2834

.rpc_resp = &res,

2818

};

2835

};

2819

int status = -ENOMEM;

2836

int status = -ENOMEM;

2820

2837

2821

res.fattr = nfs_alloc_fattr();

2838

res.fattr = nfs_alloc_fattr();

2822

res.dir_attr = nfs_alloc_fattr();

2839

res.dir_attr = nfs_alloc_fattr();

2823

if (res.fattr == NULL || res.dir_attr == NULL)

2840

if (res.fattr == NULL || res.dir_attr == NULL)

2824

goto out;

2841

goto out;

2825

2842

2826

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

2843

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

2827

if (!status) {

2844

if (!status) {

2828

update_changeattr(dir, &res.cinfo);

2845

update_changeattr(dir, &res.cinfo);

2829

nfs_post_op_update_inode(dir, res.dir_attr);

2846

nfs_post_op_update_inode(dir, res.dir_attr);

2830

nfs_post_op_update_inode(inode, res.fattr);

2847

nfs_post_op_update_inode(inode, res.fattr);

2831

}

2848

}

2832

out:

2849

out:

2833

nfs_free_fattr(res.dir_attr);

2850

nfs_free_fattr(res.dir_attr);

2834

nfs_free_fattr(res.fattr);

2851

nfs_free_fattr(res.fattr);

2835

return status;

2852

return status;

2836

}

2853

}

2837

2854

2838

static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)

2855

static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)

2839

{

2856

{

2840

struct nfs4_exception exception = { };

2857

struct nfs4_exception exception = { };

2841

int err;

2858

int err;

2842

do {

2859

do {

2843

err = nfs4_handle_exception(NFS_SERVER(inode),

2860

err = nfs4_handle_exception(NFS_SERVER(inode),

2844

_nfs4_proc_link(inode, dir, name),

2861

_nfs4_proc_link(inode, dir, name),

2845

&exception);

2862

&exception);

2846

} while (exception.retry);

2863

} while (exception.retry);

2847

return err;

2864

return err;

2848

}

2865

}

2849

2866

2850

struct nfs4_createdata {

2867

struct nfs4_createdata {

2851

struct rpc_message msg;

2868

struct rpc_message msg;

2852

struct nfs4_create_arg arg;

2869

struct nfs4_create_arg arg;

2853

struct nfs4_create_res res;

2870

struct nfs4_create_res res;

2854

struct nfs_fh fh;

2871

struct nfs_fh fh;

2855

struct nfs_fattr fattr;

2872

struct nfs_fattr fattr;

2856

struct nfs_fattr dir_fattr;

2873

struct nfs_fattr dir_fattr;

2857

};

2874

};

2858

2875

2859

static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,

2876

static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,

2860

struct qstr *name, struct iattr *sattr, u32 ftype)

2877

struct qstr *name, struct iattr *sattr, u32 ftype)

2861

{

2878

{

2862

struct nfs4_createdata *data;

2879

struct nfs4_createdata *data;

2863

2880

2864

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

2881

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

2865

if (data != NULL) {

2882

if (data != NULL) {

2866

struct nfs_server *server = NFS_SERVER(dir);

2883

struct nfs_server *server = NFS_SERVER(dir);

2867

2884

2868

data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];

2885

data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];

2869

data->msg.rpc_argp = &data->arg;

2886

data->msg.rpc_argp = &data->arg;

2870

data->msg.rpc_resp = &data->res;

2887

data->msg.rpc_resp = &data->res;

2871

data->arg.dir_fh = NFS_FH(dir);

2888

data->arg.dir_fh = NFS_FH(dir);

2872

data->arg.server = server;

2889

data->arg.server = server;

2873

data->arg.name = name;

2890

data->arg.name = name;

2874

data->arg.attrs = sattr;

2891

data->arg.attrs = sattr;

2875

data->arg.ftype = ftype;

2892

data->arg.ftype = ftype;

2876

data->arg.bitmask = server->attr_bitmask;

2893

data->arg.bitmask = server->attr_bitmask;

2877

data->res.server = server;

2894

data->res.server = server;

2878

data->res.fh = &data->fh;

2895

data->res.fh = &data->fh;

2879

data->res.fattr = &data->fattr;

2896

data->res.fattr = &data->fattr;

2880

data->res.dir_fattr = &data->dir_fattr;

2897

data->res.dir_fattr = &data->dir_fattr;

2881

nfs_fattr_init(data->res.fattr);

2898

nfs_fattr_init(data->res.fattr);

2882

nfs_fattr_init(data->res.dir_fattr);

2899

nfs_fattr_init(data->res.dir_fattr);

2883

}

2900

}

2884

return data;

2901

return data;

2885

}

2902

}

2886

2903

2887

static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)

2904

static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)

2888

{

2905

{

2889

int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,

2906

int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,

2890

&data->arg.seq_args, &data->res.seq_res, 1);

2907

&data->arg.seq_args, &data->res.seq_res, 1);

2891

if (status == 0) {

2908

if (status == 0) {

2892

update_changeattr(dir, &data->res.dir_cinfo);

2909

update_changeattr(dir, &data->res.dir_cinfo);

2893

nfs_post_op_update_inode(dir, data->res.dir_fattr);

2910

nfs_post_op_update_inode(dir, data->res.dir_fattr);

2894

status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);

2911

status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);

2895

}

2912

}

2896

return status;

2913

return status;

2897

}

2914

}

2898

2915

2899

static void nfs4_free_createdata(struct nfs4_createdata *data)

2916

static void nfs4_free_createdata(struct nfs4_createdata *data)

2900

{

2917

{

2901

kfree(data);

2918

kfree(data);

2902

}

2919

}

2903

2920

2904

static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,

2921

static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,

2905

struct page *page, unsigned int len, struct iattr *sattr)

2922

struct page *page, unsigned int len, struct iattr *sattr)

2906

{

2923

{

2907

struct nfs4_createdata *data;

2924

struct nfs4_createdata *data;

2908

int status = -ENAMETOOLONG;

2925

int status = -ENAMETOOLONG;

2909

2926

2910

if (len > NFS4_MAXPATHLEN)

2927

if (len > NFS4_MAXPATHLEN)

2911

goto out;

2928

goto out;

2912

2929

2913

status = -ENOMEM;

2930

status = -ENOMEM;

2914

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);

2931

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);

2915

if (data == NULL)

2932

if (data == NULL)

2916

goto out;

2933

goto out;

2917

2934

2918

data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];

2935

data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];

2919

data->arg.u.symlink.pages = &page;

2936

data->arg.u.symlink.pages = &page;

2920

data->arg.u.symlink.len = len;

2937

data->arg.u.symlink.len = len;

2921

2938

2922

status = nfs4_do_create(dir, dentry, data);

2939

status = nfs4_do_create(dir, dentry, data);

2923

2940

2924

nfs4_free_createdata(data);

2941

nfs4_free_createdata(data);

2925

out:

2942

out:

2926

return status;

2943

return status;

2927

}

2944

}

2928

2945

2929

static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,

2946

static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,

2930

struct page *page, unsigned int len, struct iattr *sattr)

2947

struct page *page, unsigned int len, struct iattr *sattr)

2931

{

2948

{

2932

struct nfs4_exception exception = { };

2949

struct nfs4_exception exception = { };

2933

int err;

2950

int err;

2934

do {

2951

do {

2935

err = nfs4_handle_exception(NFS_SERVER(dir),

2952

err = nfs4_handle_exception(NFS_SERVER(dir),

2936

_nfs4_proc_symlink(dir, dentry, page,

2953

_nfs4_proc_symlink(dir, dentry, page,

2937

len, sattr),

2954

len, sattr),

2938

&exception);

2955

&exception);

2939

} while (exception.retry);

2956

} while (exception.retry);

2940

return err;

2957

return err;

2941

}

2958

}

2942

2959

2943

static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,

2960

static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,

2944

struct iattr *sattr)

2961

struct iattr *sattr)

2945

{

2962

{

2946

struct nfs4_createdata *data;

2963

struct nfs4_createdata *data;

2947

int status = -ENOMEM;

2964

int status = -ENOMEM;

2948

2965

2949

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);

2966

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);

2950

if (data == NULL)

2967

if (data == NULL)

2951

goto out;

2968

goto out;

2952

2969

2953

status = nfs4_do_create(dir, dentry, data);

2970

status = nfs4_do_create(dir, dentry, data);

2954

2971

2955

nfs4_free_createdata(data);

2972

nfs4_free_createdata(data);

2956

out:

2973

out:

2957

return status;

2974

return status;

2958

}

2975

}

2959

2976

2960

static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,

2977

static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,

2961

struct iattr *sattr)

2978

struct iattr *sattr)

2962

{

2979

{

2963

struct nfs4_exception exception = { };

2980

struct nfs4_exception exception = { };

2964

int err;

2981

int err;

2965

2982

2966

sattr->ia_mode &= ~current_umask();

2983

sattr->ia_mode &= ~current_umask();

2967

do {

2984

do {

2968

err = nfs4_handle_exception(NFS_SERVER(dir),

2985

err = nfs4_handle_exception(NFS_SERVER(dir),

2969

_nfs4_proc_mkdir(dir, dentry, sattr),

2986

_nfs4_proc_mkdir(dir, dentry, sattr),

2970

&exception);

2987

&exception);

2971

} while (exception.retry);

2988

} while (exception.retry);

2972

return err;

2989

return err;

2973

}

2990

}

2974

2991

2975

static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,

2992

static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,

2976

u64 cookie, struct page **pages, unsigned int count, int plus)

2993

u64 cookie, struct page **pages, unsigned int count, int plus)

2977

{

2994

{

2978

struct inode *dir = dentry->d_inode;

2995

struct inode *dir = dentry->d_inode;

2979

struct nfs4_readdir_arg args = {

2996

struct nfs4_readdir_arg args = {

2980

.fh = NFS_FH(dir),

2997

.fh = NFS_FH(dir),

2981

.pages = pages,

2998

.pages = pages,

2982

.pgbase = 0,

2999

.pgbase = 0,

2983

.count = count,

3000

.count = count,

2984

.bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,

3001

.bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,

2985

.plus = plus,

3002

.plus = plus,

2986

};

3003

};

2987

struct nfs4_readdir_res res;

3004

struct nfs4_readdir_res res;

2988

struct rpc_message msg = {

3005

struct rpc_message msg = {

2989

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],

3006

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],

2990

.rpc_argp = &args,

3007

.rpc_argp = &args,

2991

.rpc_resp = &res,

3008

.rpc_resp = &res,

2992

.rpc_cred = cred,

3009

.rpc_cred = cred,

2993

};

3010

};

2994

int status;

3011

int status;

2995

3012

2996

dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,

3013

dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,

2997

dentry->d_parent->d_name.name,

3014

dentry->d_parent->d_name.name,

2998

dentry->d_name.name,

3015

dentry->d_name.name,

2999

(unsigned long long)cookie);

3016

(unsigned long long)cookie);

3000

nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);

3017

nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);

3001

res.pgbase = args.pgbase;

3018

res.pgbase = args.pgbase;

3002

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

3019

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

3003

if (status >= 0) {

3020

if (status >= 0) {

3004

memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);

3021

memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);

3005

status += args.pgbase;

3022

status += args.pgbase;

3006

}

3023

}

3007

3024

3008

nfs_invalidate_atime(dir);

3025

nfs_invalidate_atime(dir);

3009

3026

3010

dprintk("%s: returns %d\n", __func__, status);

3027

dprintk("%s: returns %d\n", __func__, status);

3011

return status;

3028

return status;

3012

}

3029

}

3013

3030

3014

static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,

3031

static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,

3015

u64 cookie, struct page **pages, unsigned int count, int plus)

3032

u64 cookie, struct page **pages, unsigned int count, int plus)

3016

{

3033

{

3017

struct nfs4_exception exception = { };

3034

struct nfs4_exception exception = { };

3018

int err;

3035

int err;

3019

do {

3036

do {

3020

err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),

3037

err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),

3021

_nfs4_proc_readdir(dentry, cred, cookie,

3038

_nfs4_proc_readdir(dentry, cred, cookie,

3022

pages, count, plus),

3039

pages, count, plus),

3023

&exception);

3040

&exception);

3024

} while (exception.retry);

3041

} while (exception.retry);

3025

return err;

3042

return err;

3026

}

3043

}

3027

3044

3028

static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,

3045

static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,

3029

struct iattr *sattr, dev_t rdev)

3046

struct iattr *sattr, dev_t rdev)

3030

{

3047

{

3031

struct nfs4_createdata *data;

3048

struct nfs4_createdata *data;

3032

int mode = sattr->ia_mode;

3049

int mode = sattr->ia_mode;

3033

int status = -ENOMEM;

3050

int status = -ENOMEM;

3034

3051

3035

BUG_ON(!(sattr->ia_valid & ATTR_MODE));

3052

BUG_ON(!(sattr->ia_valid & ATTR_MODE));

3036

BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));

3053

BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));

3037

3054

3038

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);

3055

data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);

3039

if (data == NULL)

3056

if (data == NULL)

3040

goto out;

3057

goto out;

3041

3058

3042

if (S_ISFIFO(mode))

3059

if (S_ISFIFO(mode))

3043

data->arg.ftype = NF4FIFO;

3060

data->arg.ftype = NF4FIFO;

3044

else if (S_ISBLK(mode)) {

3061

else if (S_ISBLK(mode)) {

3045

data->arg.ftype = NF4BLK;

3062

data->arg.ftype = NF4BLK;

3046

data->arg.u.device.specdata1 = MAJOR(rdev);

3063

data->arg.u.device.specdata1 = MAJOR(rdev);

3047

data->arg.u.device.specdata2 = MINOR(rdev);

3064

data->arg.u.device.specdata2 = MINOR(rdev);

3048

}

3065

}

3049

else if (S_ISCHR(mode)) {

3066

else if (S_ISCHR(mode)) {

3050

data->arg.ftype = NF4CHR;

3067

data->arg.ftype = NF4CHR;

3051

data->arg.u.device.specdata1 = MAJOR(rdev);

3068

data->arg.u.device.specdata1 = MAJOR(rdev);

3052

data->arg.u.device.specdata2 = MINOR(rdev);

3069

data->arg.u.device.specdata2 = MINOR(rdev);

3053

}

3070

}

3054

3071

3055

status = nfs4_do_create(dir, dentry, data);

3072

status = nfs4_do_create(dir, dentry, data);

3056

3073

3057

nfs4_free_createdata(data);

3074

nfs4_free_createdata(data);

3058

out:

3075

out:

3059

return status;

3076

return status;

3060

}

3077

}

3061

3078

3062

static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,

3079

static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,

3063

struct iattr *sattr, dev_t rdev)

3080

struct iattr *sattr, dev_t rdev)

3064

{

3081

{

3065

struct nfs4_exception exception = { };

3082

struct nfs4_exception exception = { };

3066

int err;

3083

int err;

3067

3084

3068

sattr->ia_mode &= ~current_umask();

3085

sattr->ia_mode &= ~current_umask();

3069

do {

3086

do {

3070

err = nfs4_handle_exception(NFS_SERVER(dir),

3087

err = nfs4_handle_exception(NFS_SERVER(dir),

3071

_nfs4_proc_mknod(dir, dentry, sattr, rdev),

3088

_nfs4_proc_mknod(dir, dentry, sattr, rdev),

3072

&exception);

3089

&exception);

3073

} while (exception.retry);

3090

} while (exception.retry);

3074

return err;

3091

return err;

3075

}

3092

}

3076

3093

3077

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

3094

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

3078

struct nfs_fsstat *fsstat)

3095

struct nfs_fsstat *fsstat)

3079

{

3096

{

3080

struct nfs4_statfs_arg args = {

3097

struct nfs4_statfs_arg args = {

3081

.fh = fhandle,

3098

.fh = fhandle,

3082

.bitmask = server->attr_bitmask,

3099

.bitmask = server->attr_bitmask,

3083

};

3100

};

3084

struct nfs4_statfs_res res = {

3101

struct nfs4_statfs_res res = {

3085

.fsstat = fsstat,

3102

.fsstat = fsstat,

3086

};

3103

};

3087

struct rpc_message msg = {

3104

struct rpc_message msg = {

3088

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],

3105

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],

3089

.rpc_argp = &args,

3106

.rpc_argp = &args,

3090

.rpc_resp = &res,

3107

.rpc_resp = &res,

3091

};

3108

};

3092

3109

3093

nfs_fattr_init(fsstat->fattr);

3110

nfs_fattr_init(fsstat->fattr);

3094

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

3111

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

3095

}

3112

}

3096

3113

3097

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

3114

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

3098

{

3115

{

3099

struct nfs4_exception exception = { };

3116

struct nfs4_exception exception = { };

3100

int err;

3117

int err;

3101

do {

3118

do {

3102

err = nfs4_handle_exception(server,

3119

err = nfs4_handle_exception(server,

3103

_nfs4_proc_statfs(server, fhandle, fsstat),

3120

_nfs4_proc_statfs(server, fhandle, fsstat),

3104

&exception);

3121

&exception);

3105

} while (exception.retry);

3122

} while (exception.retry);

3106

return err;

3123

return err;

3107

}

3124

}

3108

3125

3109

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

3126

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

3110

struct nfs_fsinfo *fsinfo)

3127

struct nfs_fsinfo *fsinfo)

3111

{

3128

{

3112

struct nfs4_fsinfo_arg args = {

3129

struct nfs4_fsinfo_arg args = {

3113

.fh = fhandle,

3130

.fh = fhandle,

3114

.bitmask = server->attr_bitmask,

3131

.bitmask = server->attr_bitmask,

3115

};

3132

};

3116

struct nfs4_fsinfo_res res = {

3133

struct nfs4_fsinfo_res res = {

3117

.fsinfo = fsinfo,

3134

.fsinfo = fsinfo,

3118

};

3135

};

3119

struct rpc_message msg = {

3136

struct rpc_message msg = {

3120

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],

3137

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],

3121

.rpc_argp = &args,

3138

.rpc_argp = &args,

3122

.rpc_resp = &res,

3139

.rpc_resp = &res,

3123

};

3140

};

3124

3141

3125

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

3142

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

3126

}

3143

}

3127

3144

3128

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

3145

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

3129

{

3146

{

3130

struct nfs4_exception exception = { };

3147

struct nfs4_exception exception = { };

3131

int err;

3148

int err;

3132

3149

3133

do {

3150

do {

3134

err = nfs4_handle_exception(server,

3151

err = nfs4_handle_exception(server,

3135

_nfs4_do_fsinfo(server, fhandle, fsinfo),

3152

_nfs4_do_fsinfo(server, fhandle, fsinfo),

3136

&exception);

3153

&exception);

3137

} while (exception.retry);

3154

} while (exception.retry);

3138

return err;

3155

return err;

3139

}

3156

}

3140

3157

3141

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

3158

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

3142

{

3159

{

3143

nfs_fattr_init(fsinfo->fattr);

3160

nfs_fattr_init(fsinfo->fattr);

3144

return nfs4_do_fsinfo(server, fhandle, fsinfo);

3161

return nfs4_do_fsinfo(server, fhandle, fsinfo);

3145

}

3162

}

3146

3163

3147

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

3164

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

3148

struct nfs_pathconf *pathconf)

3165

struct nfs_pathconf *pathconf)

3149

{

3166

{

3150

struct nfs4_pathconf_arg args = {

3167

struct nfs4_pathconf_arg args = {

3151

.fh = fhandle,

3168

.fh = fhandle,

3152

.bitmask = server->attr_bitmask,

3169

.bitmask = server->attr_bitmask,

3153

};

3170

};

3154

struct nfs4_pathconf_res res = {

3171

struct nfs4_pathconf_res res = {

3155

.pathconf = pathconf,

3172

.pathconf = pathconf,

3156

};

3173

};

3157

struct rpc_message msg = {

3174

struct rpc_message msg = {

3158

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],

3175

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],

3159

.rpc_argp = &args,

3176

.rpc_argp = &args,

3160

.rpc_resp = &res,

3177

.rpc_resp = &res,

3161

};

3178

};

3162

3179

3163

/* None of the pathconf attributes are mandatory to implement */

3180

/* None of the pathconf attributes are mandatory to implement */

3164

if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {

3181

if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {

3165

memset(pathconf, 0, sizeof(*pathconf));

3182

memset(pathconf, 0, sizeof(*pathconf));

3166

return 0;

3183

return 0;

3167

}

3184

}

3168

3185

3169

nfs_fattr_init(pathconf->fattr);

3186

nfs_fattr_init(pathconf->fattr);

3170

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

3187

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

3171

}

3188

}

3172

3189

3173

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

3190

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

3174

struct nfs_pathconf *pathconf)

3191

struct nfs_pathconf *pathconf)

3175

{

3192

{

3176

struct nfs4_exception exception = { };

3193

struct nfs4_exception exception = { };

3177

int err;

3194

int err;

3178

3195

3179

do {

3196

do {

3180

err = nfs4_handle_exception(server,

3197

err = nfs4_handle_exception(server,

3181

_nfs4_proc_pathconf(server, fhandle, pathconf),

3198

_nfs4_proc_pathconf(server, fhandle, pathconf),

3182

&exception);

3199

&exception);

3183

} while (exception.retry);

3200

} while (exception.retry);

3184

return err;

3201

return err;

3185

}

3202

}

3186

3203

3187

void __nfs4_read_done_cb(struct nfs_read_data *data)

3204

void __nfs4_read_done_cb(struct nfs_read_data *data)

3188

{

3205

{

3189

nfs_invalidate_atime(data->inode);

3206

nfs_invalidate_atime(data->inode);

3190

}

3207

}

3191

3208

3192

static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)

3209

static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)

3193

{

3210

{

3194

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

3211

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

3195

3212

3196

if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {

3213

if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {

3197

nfs_restart_rpc(task, server->nfs_client);

3214

nfs_restart_rpc(task, server->nfs_client);

3198

return -EAGAIN;

3215

return -EAGAIN;

3199

}

3216

}

3200

3217

3201

__nfs4_read_done_cb(data);

3218

__nfs4_read_done_cb(data);

3202

if (task->tk_status > 0)

3219

if (task->tk_status > 0)

3203

renew_lease(server, data->timestamp);

3220

renew_lease(server, data->timestamp);

3204

return 0;

3221

return 0;

3205

}

3222

}

3206

3223

3207

static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)

3224

static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)

3208

{

3225

{

3209

3226

3210

dprintk("--> %s\n", __func__);

3227

dprintk("--> %s\n", __func__);

3211

3228

3212

if (!nfs4_sequence_done(task, &data->res.seq_res))

3229

if (!nfs4_sequence_done(task, &data->res.seq_res))

3213

return -EAGAIN;

3230

return -EAGAIN;

3214

3231

3215

return data->read_done_cb ? data->read_done_cb(task, data) :

3232

return data->read_done_cb ? data->read_done_cb(task, data) :

3216

nfs4_read_done_cb(task, data);

3233

nfs4_read_done_cb(task, data);

3217

}

3234

}

3218

3235

3219

static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)

3236

static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)

3220

{

3237

{

3221

data->timestamp = jiffies;

3238

data->timestamp = jiffies;

3222

data->read_done_cb = nfs4_read_done_cb;

3239

data->read_done_cb = nfs4_read_done_cb;

3223

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];

3240

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];

3224

}

3241

}

3225

3242

3226

/* Reset the the nfs_read_data to send the read to the MDS. */

3243

/* Reset the the nfs_read_data to send the read to the MDS. */

3227

void nfs4_reset_read(struct rpc_task *task, struct nfs_read_data *data)

3244

void nfs4_reset_read(struct rpc_task *task, struct nfs_read_data *data)

3228

{

3245

{

3229

dprintk("%s Reset task for i/o through\n", __func__);

3246

dprintk("%s Reset task for i/o through\n", __func__);

3230

put_lseg(data->lseg);

3247

put_lseg(data->lseg);

3231

data->lseg = NULL;

3248

data->lseg = NULL;

3232

/* offsets will differ in the dense stripe case */

3249

/* offsets will differ in the dense stripe case */

3233

data->args.offset = data->mds_offset;

3250

data->args.offset = data->mds_offset;

3234

data->ds_clp = NULL;

3251

data->ds_clp = NULL;

3235

data->args.fh = NFS_FH(data->inode);

3252

data->args.fh = NFS_FH(data->inode);

3236

data->read_done_cb = nfs4_read_done_cb;

3253

data->read_done_cb = nfs4_read_done_cb;

3237

task->tk_ops = data->mds_ops;

3254

task->tk_ops = data->mds_ops;

3238

rpc_task_reset_client(task, NFS_CLIENT(data->inode));

3255

rpc_task_reset_client(task, NFS_CLIENT(data->inode));

3239

}

3256

}

3240

EXPORT_SYMBOL_GPL(nfs4_reset_read);

3257

EXPORT_SYMBOL_GPL(nfs4_reset_read);

3241

3258

3242

static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)

3259

static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)

3243

{

3260

{

3244

struct inode *inode = data->inode;

3261

struct inode *inode = data->inode;

3245

3262

3246

if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {

3263

if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {

3247

nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client);

3264

nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client);

3248

return -EAGAIN;

3265

return -EAGAIN;

3249

}

3266

}

3250

if (task->tk_status >= 0) {

3267

if (task->tk_status >= 0) {

3251

renew_lease(NFS_SERVER(inode), data->timestamp);

3268

renew_lease(NFS_SERVER(inode), data->timestamp);

3252

nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);

3269

nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);

3253

}

3270

}

3254

return 0;

3271

return 0;

3255

}

3272

}

3256

3273

3257

static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)

3274

static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)

3258

{

3275

{

3259

if (!nfs4_sequence_done(task, &data->res.seq_res))

3276

if (!nfs4_sequence_done(task, &data->res.seq_res))

3260

return -EAGAIN;

3277

return -EAGAIN;

3261

return data->write_done_cb ? data->write_done_cb(task, data) :

3278

return data->write_done_cb ? data->write_done_cb(task, data) :

3262

nfs4_write_done_cb(task, data);

3279

nfs4_write_done_cb(task, data);

3263

}

3280

}

3264

3281

3265

/* Reset the the nfs_write_data to send the write to the MDS. */

3282

/* Reset the the nfs_write_data to send the write to the MDS. */

3266

void nfs4_reset_write(struct rpc_task *task, struct nfs_write_data *data)

3283

void nfs4_reset_write(struct rpc_task *task, struct nfs_write_data *data)

3267

{

3284

{

3268

dprintk("%s Reset task for i/o through\n", __func__);

3285

dprintk("%s Reset task for i/o through\n", __func__);

3269

put_lseg(data->lseg);

3286

put_lseg(data->lseg);

3270

data->lseg = NULL;

3287

data->lseg = NULL;

3271

data->ds_clp = NULL;

3288

data->ds_clp = NULL;

3272

data->write_done_cb = nfs4_write_done_cb;

3289

data->write_done_cb = nfs4_write_done_cb;

3273

data->args.fh = NFS_FH(data->inode);

3290

data->args.fh = NFS_FH(data->inode);

3274

data->args.bitmask = data->res.server->cache_consistency_bitmask;

3291

data->args.bitmask = data->res.server->cache_consistency_bitmask;

3275

data->args.offset = data->mds_offset;

3292

data->args.offset = data->mds_offset;

3276

data->res.fattr = &data->fattr;

3293

data->res.fattr = &data->fattr;

3277

task->tk_ops = data->mds_ops;

3294

task->tk_ops = data->mds_ops;

3278

rpc_task_reset_client(task, NFS_CLIENT(data->inode));

3295

rpc_task_reset_client(task, NFS_CLIENT(data->inode));

3279

}

3296

}

3280

EXPORT_SYMBOL_GPL(nfs4_reset_write);

3297

EXPORT_SYMBOL_GPL(nfs4_reset_write);

3281

3298

3282

static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)

3299

static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)

3283

{

3300

{

3284

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

3301

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

3285

3302

3286

if (data->lseg) {

3303

if (data->lseg) {

3287

data->args.bitmask = NULL;

3304

data->args.bitmask = NULL;

3288

data->res.fattr = NULL;

3305

data->res.fattr = NULL;

3289

} else

3306

} else

3290

data->args.bitmask = server->cache_consistency_bitmask;

3307

data->args.bitmask = server->cache_consistency_bitmask;

3291

if (!data->write_done_cb)

3308

if (!data->write_done_cb)

3292

data->write_done_cb = nfs4_write_done_cb;

3309

data->write_done_cb = nfs4_write_done_cb;

3293

data->res.server = server;

3310

data->res.server = server;

3294

data->timestamp = jiffies;

3311

data->timestamp = jiffies;

3295

3312

3296

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];

3313

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];

3297

}

3314

}

3298

3315

3299

static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_write_data *data)

3316

static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_write_data *data)

3300

{

3317

{

3301

struct inode *inode = data->inode;

3318

struct inode *inode = data->inode;

3302

3319

3303

if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {

3320

if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {

3304

nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client);

3321

nfs_restart_rpc(task, NFS_SERVER(inode)->nfs_client);

3305

return -EAGAIN;

3322

return -EAGAIN;

3306

}

3323

}

3307

nfs_refresh_inode(inode, data->res.fattr);

3324

nfs_refresh_inode(inode, data->res.fattr);

3308

return 0;

3325

return 0;

3309

}

3326

}

3310

3327

3311

static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)

3328

static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)

3312

{

3329

{

3313

if (!nfs4_sequence_done(task, &data->res.seq_res))

3330

if (!nfs4_sequence_done(task, &data->res.seq_res))

3314

return -EAGAIN;

3331

return -EAGAIN;

3315

return data->write_done_cb(task, data);

3332

return data->write_done_cb(task, data);

3316

}

3333

}

3317

3334

3318

static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)

3335

static void nfs4_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)

3319

{

3336

{

3320

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

3337

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

3321

3338

3322

if (data->lseg) {

3339

if (data->lseg) {

3323

data->args.bitmask = NULL;

3340

data->args.bitmask = NULL;

3324

data->res.fattr = NULL;

3341

data->res.fattr = NULL;

3325

} else

3342

} else

3326

data->args.bitmask = server->cache_consistency_bitmask;

3343

data->args.bitmask = server->cache_consistency_bitmask;

3327

if (!data->write_done_cb)

3344

if (!data->write_done_cb)

3328

data->write_done_cb = nfs4_commit_done_cb;

3345

data->write_done_cb = nfs4_commit_done_cb;

3329

data->res.server = server;

3346

data->res.server = server;

3330

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];

3347

msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];

3331

}

3348

}

3332

3349

3333

struct nfs4_renewdata {

3350

struct nfs4_renewdata {

3334

struct nfs_client *client;

3351

struct nfs_client *client;

3335

unsigned long timestamp;

3352

unsigned long timestamp;

3336

};

3353

};

3337

3354

3338

/*

3355

/*

3339

* nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special

3356

* nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special

3340

* standalone procedure for queueing an asynchronous RENEW.

3357

* standalone procedure for queueing an asynchronous RENEW.

3341

*/

3358

*/

3342

static void nfs4_renew_release(void *calldata)

3359

static void nfs4_renew_release(void *calldata)

3343

{

3360

{

3344

struct nfs4_renewdata *data = calldata;

3361

struct nfs4_renewdata *data = calldata;

3345

struct nfs_client *clp = data->client;

3362

struct nfs_client *clp = data->client;

3346

3363

3347

if (atomic_read(&clp->cl_count) > 1)

3364

if (atomic_read(&clp->cl_count) > 1)

3348

nfs4_schedule_state_renewal(clp);

3365

nfs4_schedule_state_renewal(clp);

3349

nfs_put_client(clp);

3366

nfs_put_client(clp);

3350

kfree(data);

3367

kfree(data);

3351

}

3368

}

3352

3369

3353

static void nfs4_renew_done(struct rpc_task *task, void *calldata)

3370

static void nfs4_renew_done(struct rpc_task *task, void *calldata)

3354

{

3371

{

3355

struct nfs4_renewdata *data = calldata;

3372

struct nfs4_renewdata *data = calldata;

3356

struct nfs_client *clp = data->client;

3373

struct nfs_client *clp = data->client;

3357

unsigned long timestamp = data->timestamp;

3374

unsigned long timestamp = data->timestamp;

3358

3375

3359

if (task->tk_status < 0) {

3376

if (task->tk_status < 0) {

3360

/* Unless we're shutting down, schedule state recovery! */

3377

/* Unless we're shutting down, schedule state recovery! */

3361

if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) != 0)

3378

if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) != 0)

3362

nfs4_schedule_lease_recovery(clp);

3379

nfs4_schedule_lease_recovery(clp);

3363

return;

3380

return;

3364

}

3381

}

3365

do_renew_lease(clp, timestamp);

3382

do_renew_lease(clp, timestamp);

3366

}

3383

}

3367

3384

3368

static const struct rpc_call_ops nfs4_renew_ops = {

3385

static const struct rpc_call_ops nfs4_renew_ops = {

3369

.rpc_call_done = nfs4_renew_done,

3386

.rpc_call_done = nfs4_renew_done,

3370

.rpc_release = nfs4_renew_release,

3387

.rpc_release = nfs4_renew_release,

3371

};

3388

};

3372

3389

3373

int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred)

3390

int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred)

3374

{

3391

{

3375

struct rpc_message msg = {

3392

struct rpc_message msg = {

3376

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],

3393

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],

3377

.rpc_argp = clp,

3394

.rpc_argp = clp,

3378

.rpc_cred = cred,

3395

.rpc_cred = cred,

3379

};

3396

};

3380

struct nfs4_renewdata *data;

3397

struct nfs4_renewdata *data;

3381

3398

3382

if (!atomic_inc_not_zero(&clp->cl_count))

3399

if (!atomic_inc_not_zero(&clp->cl_count))

3383

return -EIO;

3400

return -EIO;

3384

data = kmalloc(sizeof(*data), GFP_KERNEL);

3401

data = kmalloc(sizeof(*data), GFP_KERNEL);

3385

if (data == NULL)

3402

if (data == NULL)

3386

return -ENOMEM;

3403

return -ENOMEM;

3387

data->client = clp;

3404

data->client = clp;

3388

data->timestamp = jiffies;

3405

data->timestamp = jiffies;

3389

return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,

3406

return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,

3390

&nfs4_renew_ops, data);

3407

&nfs4_renew_ops, data);

3391

}

3408

}

3392

3409

3393

int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)

3410

int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)

3394

{

3411

{

3395

struct rpc_message msg = {

3412

struct rpc_message msg = {

3396

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],

3413

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],

3397

.rpc_argp = clp,

3414

.rpc_argp = clp,

3398

.rpc_cred = cred,

3415

.rpc_cred = cred,

3399

};

3416

};

3400

unsigned long now = jiffies;

3417

unsigned long now = jiffies;

3401

int status;

3418

int status;

3402

3419

3403

status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);

3420

status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);

3404

if (status < 0)

3421

if (status < 0)

3405

return status;

3422

return status;

3406

do_renew_lease(clp, now);

3423

do_renew_lease(clp, now);

3407

return 0;

3424

return 0;

3408

}

3425

}

3409

3426

3410

static inline int nfs4_server_supports_acls(struct nfs_server *server)

3427

static inline int nfs4_server_supports_acls(struct nfs_server *server)

3411

{

3428

{

3412

return (server->caps & NFS_CAP_ACLS)

3429

return (server->caps & NFS_CAP_ACLS)

3413

&& (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)

3430

&& (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)

3414

&& (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);

3431

&& (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);

3415

}

3432

}

3416

3433

3417

/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that

3434

/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that

3418

* it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on

3435

* it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on

3419

* the stack.

3436

* the stack.

3420

*/

3437

*/

3421

#define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)

3438

#define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)

3422

3439

3423

static void buf_to_pages(const void *buf, size_t buflen,

3440

static void buf_to_pages(const void *buf, size_t buflen,

3424

struct page **pages, unsigned int *pgbase)

3441

struct page **pages, unsigned int *pgbase)

3425

{

3442

{

3426

const void *p = buf;

3443

const void *p = buf;

3427

3444

3428

*pgbase = offset_in_page(buf);

3445

*pgbase = offset_in_page(buf);

3429

p -= *pgbase;

3446

p -= *pgbase;

3430

while (p < buf + buflen) {

3447

while (p < buf + buflen) {

3431

*(pages++) = virt_to_page(p);

3448

*(pages++) = virt_to_page(p);

3432

p += PAGE_CACHE_SIZE;

3449

p += PAGE_CACHE_SIZE;

3433

}

3450

}

3434

}

3451

}

3435

3452

3436

static int buf_to_pages_noslab(const void *buf, size_t buflen,

3453

static int buf_to_pages_noslab(const void *buf, size_t buflen,

3437

struct page **pages, unsigned int *pgbase)

3454

struct page **pages, unsigned int *pgbase)

3438

{

3455

{

3439

struct page *newpage, **spages;

3456

struct page *newpage, **spages;

3440

int rc = 0;

3457

int rc = 0;

3441

size_t len;

3458

size_t len;

3442

spages = pages;

3459

spages = pages;

3443

3460

3444

do {

3461

do {

3445

len = min_t(size_t, PAGE_CACHE_SIZE, buflen);

3462

len = min_t(size_t, PAGE_CACHE_SIZE, buflen);

3446

newpage = alloc_page(GFP_KERNEL);

3463

newpage = alloc_page(GFP_KERNEL);

3447

3464

3448

if (newpage == NULL)

3465

if (newpage == NULL)

3449

goto unwind;

3466

goto unwind;

3450

memcpy(page_address(newpage), buf, len);

3467

memcpy(page_address(newpage), buf, len);

3451

buf += len;

3468

buf += len;

3452

buflen -= len;

3469

buflen -= len;

3453

*pages++ = newpage;

3470

*pages++ = newpage;

3454

rc++;

3471

rc++;

3455

} while (buflen != 0);

3472

} while (buflen != 0);

3456

3473

3457

return rc;

3474

return rc;

3458

3475

3459

unwind:

3476

unwind:

3460

for(; rc > 0; rc--)

3477

for(; rc > 0; rc--)

3461

__free_page(spages[rc-1]);

3478

__free_page(spages[rc-1]);

3462

return -ENOMEM;

3479

return -ENOMEM;

3463

}

3480

}

3464

3481

3465

struct nfs4_cached_acl {

3482

struct nfs4_cached_acl {

3466

int cached;

3483

int cached;

3467

size_t len;

3484

size_t len;

3468

char data[0];

3485

char data[0];

3469

};

3486

};

3470

3487

3471

static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)

3488

static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)

3472

{

3489

{

3473

struct nfs_inode *nfsi = NFS_I(inode);

3490

struct nfs_inode *nfsi = NFS_I(inode);

3474

3491

3475

spin_lock(&inode->i_lock);

3492

spin_lock(&inode->i_lock);

3476

kfree(nfsi->nfs4_acl);

3493

kfree(nfsi->nfs4_acl);

3477

nfsi->nfs4_acl = acl;

3494

nfsi->nfs4_acl = acl;

3478

spin_unlock(&inode->i_lock);

3495

spin_unlock(&inode->i_lock);

3479

}

3496

}

3480

3497

3481

static void nfs4_zap_acl_attr(struct inode *inode)

3498

static void nfs4_zap_acl_attr(struct inode *inode)

3482

{

3499

{

3483

nfs4_set_cached_acl(inode, NULL);

3500

nfs4_set_cached_acl(inode, NULL);

3484

}

3501

}

3485

3502

3486

static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)

3503

static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)

3487

{

3504

{

3488

struct nfs_inode *nfsi = NFS_I(inode);

3505

struct nfs_inode *nfsi = NFS_I(inode);

3489

struct nfs4_cached_acl *acl;

3506

struct nfs4_cached_acl *acl;

3490

int ret = -ENOENT;

3507

int ret = -ENOENT;

3491

3508

3492

spin_lock(&inode->i_lock);

3509

spin_lock(&inode->i_lock);

3493

acl = nfsi->nfs4_acl;

3510

acl = nfsi->nfs4_acl;

3494

if (acl == NULL)

3511

if (acl == NULL)

3495

goto out;

3512

goto out;

3496

if (buf == NULL) /* user is just asking for length */

3513

if (buf == NULL) /* user is just asking for length */

3497

goto out_len;

3514

goto out_len;

3498

if (acl->cached == 0)

3515

if (acl->cached == 0)

3499

goto out;

3516

goto out;

3500

ret = -ERANGE; /* see getxattr(2) man page */

3517

ret = -ERANGE; /* see getxattr(2) man page */

3501

if (acl->len > buflen)

3518

if (acl->len > buflen)

3502

goto out;

3519

goto out;

3503

memcpy(buf, acl->data, acl->len);

3520

memcpy(buf, acl->data, acl->len);

3504

out_len:

3521

out_len:

3505

ret = acl->len;

3522

ret = acl->len;

3506

out:

3523

out:

3507

spin_unlock(&inode->i_lock);

3524

spin_unlock(&inode->i_lock);

3508

return ret;

3525

return ret;

3509

}

3526

}

3510

3527

3511

static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)

3528

static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)

3512

{

3529

{

3513

struct nfs4_cached_acl *acl;

3530

struct nfs4_cached_acl *acl;

3514

3531

3515

if (buf && acl_len <= PAGE_SIZE) {

3532

if (buf && acl_len <= PAGE_SIZE) {

3516

acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);

3533

acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);

3517

if (acl == NULL)

3534

if (acl == NULL)

3518

goto out;

3535

goto out;

3519

acl->cached = 1;

3536

acl->cached = 1;

3520

memcpy(acl->data, buf, acl_len);

3537

memcpy(acl->data, buf, acl_len);

3521

} else {

3538

} else {

3522

acl = kmalloc(sizeof(*acl), GFP_KERNEL);

3539

acl = kmalloc(sizeof(*acl), GFP_KERNEL);

3523

if (acl == NULL)

3540

if (acl == NULL)

3524

goto out;

3541

goto out;

3525

acl->cached = 0;

3542

acl->cached = 0;

3526

}

3543

}

3527

acl->len = acl_len;

3544

acl->len = acl_len;

3528

out:

3545

out:

3529

nfs4_set_cached_acl(inode, acl);

3546

nfs4_set_cached_acl(inode, acl);

3530

}

3547

}

3531

3548

3532

static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)

3549

static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)

3533

{

3550

{

3534

struct page *pages[NFS4ACL_MAXPAGES];

3551

struct page *pages[NFS4ACL_MAXPAGES];

3535

struct nfs_getaclargs args = {

3552

struct nfs_getaclargs args = {

3536

.fh = NFS_FH(inode),

3553

.fh = NFS_FH(inode),

3537

.acl_pages = pages,

3554

.acl_pages = pages,

3538

.acl_len = buflen,

3555

.acl_len = buflen,

3539

};

3556

};

3540

struct nfs_getaclres res = {

3557

struct nfs_getaclres res = {

3541

.acl_len = buflen,

3558

.acl_len = buflen,

3542

};

3559

};

3543

void *resp_buf;

3560

void *resp_buf;

3544

struct rpc_message msg = {

3561

struct rpc_message msg = {

3545

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],

3562

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],

3546

.rpc_argp = &args,

3563

.rpc_argp = &args,

3547

.rpc_resp = &res,

3564

.rpc_resp = &res,

3548

};

3565

};

3549

struct page *localpage = NULL;

3566

struct page *localpage = NULL;

3550

int ret;

3567

int ret;

3551

3568

3552

if (buflen < PAGE_SIZE) {

3569

if (buflen < PAGE_SIZE) {

3553

/* As long as we're doing a round trip to the server anyway,

3570

/* As long as we're doing a round trip to the server anyway,

3554

* let's be prepared for a page of acl data. */

3571

* let's be prepared for a page of acl data. */

3555

localpage = alloc_page(GFP_KERNEL);

3572

localpage = alloc_page(GFP_KERNEL);

3556

resp_buf = page_address(localpage);

3573

resp_buf = page_address(localpage);

3557

if (localpage == NULL)

3574

if (localpage == NULL)

3558

return -ENOMEM;

3575

return -ENOMEM;

3559

args.acl_pages[0] = localpage;

3576

args.acl_pages[0] = localpage;

3560

args.acl_pgbase = 0;

3577

args.acl_pgbase = 0;

3561

args.acl_len = PAGE_SIZE;

3578

args.acl_len = PAGE_SIZE;

3562

} else {

3579

} else {

3563

resp_buf = buf;

3580

resp_buf = buf;

3564

buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);

3581

buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);

3565

}

3582

}

3566

ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);

3583

ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);

3567

if (ret)

3584

if (ret)

3568

goto out_free;

3585

goto out_free;

3569

if (res.acl_len > args.acl_len)

3586

if (res.acl_len > args.acl_len)

3570

nfs4_write_cached_acl(inode, NULL, res.acl_len);

3587

nfs4_write_cached_acl(inode, NULL, res.acl_len);

3571

else

3588

else

3572

nfs4_write_cached_acl(inode, resp_buf, res.acl_len);

3589

nfs4_write_cached_acl(inode, resp_buf, res.acl_len);

3573

if (buf) {

3590

if (buf) {

3574

ret = -ERANGE;

3591

ret = -ERANGE;

3575

if (res.acl_len > buflen)

3592

if (res.acl_len > buflen)

3576

goto out_free;

3593

goto out_free;

3577

if (localpage)

3594

if (localpage)

3578

memcpy(buf, resp_buf, res.acl_len);

3595

memcpy(buf, resp_buf, res.acl_len);

3579

}

3596

}

3580

ret = res.acl_len;

3597

ret = res.acl_len;

3581

out_free:

3598

out_free:

3582

if (localpage)

3599

if (localpage)

3583

__free_page(localpage);

3600

__free_page(localpage);

3584

return ret;

3601

return ret;

3585

}

3602

}

3586

3603

3587

static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)

3604

static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)

3588

{

3605

{

3589

struct nfs4_exception exception = { };

3606

struct nfs4_exception exception = { };

3590

ssize_t ret;

3607

ssize_t ret;

3591

do {

3608

do {

3592

ret = __nfs4_get_acl_uncached(inode, buf, buflen);

3609

ret = __nfs4_get_acl_uncached(inode, buf, buflen);

3593

if (ret >= 0)

3610

if (ret >= 0)

3594

break;

3611

break;

3595

ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);

3612

ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);

3596

} while (exception.retry);

3613

} while (exception.retry);

3597

return ret;

3614

return ret;

3598

}

3615

}

3599

3616

3600

static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)

3617

static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)

3601

{

3618

{

3602

struct nfs_server *server = NFS_SERVER(inode);

3619

struct nfs_server *server = NFS_SERVER(inode);

3603

int ret;

3620

int ret;

3604

3621

3605

if (!nfs4_server_supports_acls(server))

3622

if (!nfs4_server_supports_acls(server))

3606

return -EOPNOTSUPP;

3623

return -EOPNOTSUPP;

3607

ret = nfs_revalidate_inode(server, inode);

3624

ret = nfs_revalidate_inode(server, inode);

3608

if (ret < 0)

3625

if (ret < 0)

3609

return ret;

3626

return ret;

3610

if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)

3627

if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)

3611

nfs_zap_acl_cache(inode);

3628

nfs_zap_acl_cache(inode);

3612

ret = nfs4_read_cached_acl(inode, buf, buflen);

3629

ret = nfs4_read_cached_acl(inode, buf, buflen);

3613

if (ret != -ENOENT)

3630

if (ret != -ENOENT)

3614

return ret;

3631

return ret;

3615

return nfs4_get_acl_uncached(inode, buf, buflen);

3632

return nfs4_get_acl_uncached(inode, buf, buflen);

3616

}

3633

}

3617

3634

3618

static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)

3635

static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)

3619

{

3636

{

3620

struct nfs_server *server = NFS_SERVER(inode);

3637

struct nfs_server *server = NFS_SERVER(inode);

3621

struct page *pages[NFS4ACL_MAXPAGES];

3638

struct page *pages[NFS4ACL_MAXPAGES];

3622

struct nfs_setaclargs arg = {

3639

struct nfs_setaclargs arg = {

3623

.fh = NFS_FH(inode),

3640

.fh = NFS_FH(inode),

3624

.acl_pages = pages,

3641

.acl_pages = pages,

3625

.acl_len = buflen,

3642

.acl_len = buflen,

3626

};

3643

};

3627

struct nfs_setaclres res;

3644

struct nfs_setaclres res;

3628

struct rpc_message msg = {

3645

struct rpc_message msg = {

3629

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],

3646

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],

3630

.rpc_argp = &arg,

3647

.rpc_argp = &arg,

3631

.rpc_resp = &res,

3648

.rpc_resp = &res,

3632

};

3649

};

3633

int ret, i;

3650

int ret, i;

3634

3651

3635

if (!nfs4_server_supports_acls(server))

3652

if (!nfs4_server_supports_acls(server))

3636

return -EOPNOTSUPP;

3653

return -EOPNOTSUPP;

3637

i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);

3654

i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);

3638

if (i < 0)

3655

if (i < 0)

3639

return i;

3656

return i;

3640

nfs_inode_return_delegation(inode);

3657

nfs_inode_return_delegation(inode);

3641

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

3658

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

3642

3659

3643

/*

3660

/*

3644

* Free each page after tx, so the only ref left is

3661

* Free each page after tx, so the only ref left is

3645

* held by the network stack

3662

* held by the network stack

3646

*/

3663

*/

3647

for (; i > 0; i--)

3664

for (; i > 0; i--)

3648

put_page(pages[i-1]);

3665

put_page(pages[i-1]);

3649

3666

3650

/*

3667

/*

3651

* Acl update can result in inode attribute update.

3668

* Acl update can result in inode attribute update.

3652

* so mark the attribute cache invalid.

3669

* so mark the attribute cache invalid.

3653

*/

3670

*/

3654

spin_lock(&inode->i_lock);

3671

spin_lock(&inode->i_lock);

3655

NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;

3672

NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;

3656

spin_unlock(&inode->i_lock);

3673

spin_unlock(&inode->i_lock);

3657

nfs_access_zap_cache(inode);

3674

nfs_access_zap_cache(inode);

3658

nfs_zap_acl_cache(inode);

3675

nfs_zap_acl_cache(inode);

3659

return ret;

3676

return ret;

3660

}

3677

}

3661

3678

3662

static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)

3679

static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)

3663

{

3680

{

3664

struct nfs4_exception exception = { };

3681

struct nfs4_exception exception = { };

3665

int err;

3682

int err;

3666

do {

3683

do {

3667

err = nfs4_handle_exception(NFS_SERVER(inode),

3684

err = nfs4_handle_exception(NFS_SERVER(inode),

3668

__nfs4_proc_set_acl(inode, buf, buflen),

3685

__nfs4_proc_set_acl(inode, buf, buflen),

3669

&exception);

3686

&exception);

3670

} while (exception.retry);

3687

} while (exception.retry);

3671

return err;

3688

return err;

3672

}

3689

}

3673

3690

3674

static int

3691

static int

3675

nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)

3692

nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)

3676

{

3693

{

3677

struct nfs_client *clp = server->nfs_client;

3694

struct nfs_client *clp = server->nfs_client;

3678

3695

3679

if (task->tk_status >= 0)

3696

if (task->tk_status >= 0)

3680

return 0;

3697

return 0;

3681

switch(task->tk_status) {

3698

switch(task->tk_status) {

3682

case -NFS4ERR_ADMIN_REVOKED:

3699

case -NFS4ERR_ADMIN_REVOKED:

3683

case -NFS4ERR_BAD_STATEID:

3700

case -NFS4ERR_BAD_STATEID:

3684

case -NFS4ERR_OPENMODE:

3701

case -NFS4ERR_OPENMODE:

3685

if (state == NULL)

3702

if (state == NULL)

3686

break;

3703

break;

3687

nfs4_schedule_stateid_recovery(server, state);

3704

nfs4_schedule_stateid_recovery(server, state);

3688

goto wait_on_recovery;

3705

goto wait_on_recovery;

3689

case -NFS4ERR_EXPIRED:

3706

case -NFS4ERR_EXPIRED:

3690

if (state != NULL)

3707

if (state != NULL)

3691

nfs4_schedule_stateid_recovery(server, state);

3708

nfs4_schedule_stateid_recovery(server, state);

3692

case -NFS4ERR_STALE_STATEID:

3709

case -NFS4ERR_STALE_STATEID:

3693

case -NFS4ERR_STALE_CLIENTID:

3710

case -NFS4ERR_STALE_CLIENTID:

3694

nfs4_schedule_lease_recovery(clp);

3711

nfs4_schedule_lease_recovery(clp);

3695

goto wait_on_recovery;

3712

goto wait_on_recovery;

3696

#if defined(CONFIG_NFS_V4_1)

3713

#if defined(CONFIG_NFS_V4_1)

3697

case -NFS4ERR_BADSESSION:

3714

case -NFS4ERR_BADSESSION:

3698

case -NFS4ERR_BADSLOT:

3715

case -NFS4ERR_BADSLOT:

3699

case -NFS4ERR_BAD_HIGH_SLOT:

3716

case -NFS4ERR_BAD_HIGH_SLOT:

3700

case -NFS4ERR_DEADSESSION:

3717

case -NFS4ERR_DEADSESSION:

3701

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

3718

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

3702

case -NFS4ERR_SEQ_FALSE_RETRY:

3719

case -NFS4ERR_SEQ_FALSE_RETRY:

3703

case -NFS4ERR_SEQ_MISORDERED:

3720

case -NFS4ERR_SEQ_MISORDERED:

3704

dprintk("%s ERROR %d, Reset session\n", __func__,

3721

dprintk("%s ERROR %d, Reset session\n", __func__,

3705

task->tk_status);

3722

task->tk_status);

3706

nfs4_schedule_session_recovery(clp->cl_session);

3723

nfs4_schedule_session_recovery(clp->cl_session);

3707

task->tk_status = 0;

3724

task->tk_status = 0;

3708

return -EAGAIN;

3725

return -EAGAIN;

3709

#endif /* CONFIG_NFS_V4_1 */

3726

#endif /* CONFIG_NFS_V4_1 */

3710

case -NFS4ERR_DELAY:

3727

case -NFS4ERR_DELAY:

3711

nfs_inc_server_stats(server, NFSIOS_DELAY);

3728

nfs_inc_server_stats(server, NFSIOS_DELAY);

3712

case -NFS4ERR_GRACE:

3729

case -NFS4ERR_GRACE:

3713

case -EKEYEXPIRED:

3730

case -EKEYEXPIRED:

3714

rpc_delay(task, NFS4_POLL_RETRY_MAX);

3731

rpc_delay(task, NFS4_POLL_RETRY_MAX);

3715

task->tk_status = 0;

3732

task->tk_status = 0;

3716

return -EAGAIN;

3733

return -EAGAIN;

3717

case -NFS4ERR_RETRY_UNCACHED_REP:

3734

case -NFS4ERR_RETRY_UNCACHED_REP:

3718

case -NFS4ERR_OLD_STATEID:

3735

case -NFS4ERR_OLD_STATEID:

3719

task->tk_status = 0;

3736

task->tk_status = 0;

3720

return -EAGAIN;

3737

return -EAGAIN;

3721

}

3738

}

3722

task->tk_status = nfs4_map_errors(task->tk_status);

3739

task->tk_status = nfs4_map_errors(task->tk_status);

3723

return 0;

3740

return 0;

3724

wait_on_recovery:

3741

wait_on_recovery:

3725

rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);

3742

rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);

3726

if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)

3743

if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)

3727

rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);

3744

rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);

3728

task->tk_status = 0;

3745

task->tk_status = 0;

3729

return -EAGAIN;

3746

return -EAGAIN;

3730

}

3747

}

3731

3748

3732

int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,

3749

int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,

3733

unsigned short port, struct rpc_cred *cred,

3750

unsigned short port, struct rpc_cred *cred,

3734

struct nfs4_setclientid_res *res)

3751

struct nfs4_setclientid_res *res)

3735

{

3752

{

3736

nfs4_verifier sc_verifier;

3753

nfs4_verifier sc_verifier;

3737

struct nfs4_setclientid setclientid = {

3754

struct nfs4_setclientid setclientid = {

3738

.sc_verifier = &sc_verifier,

3755

.sc_verifier = &sc_verifier,

3739

.sc_prog = program,

3756

.sc_prog = program,

3740

.sc_cb_ident = clp->cl_cb_ident,

3757

.sc_cb_ident = clp->cl_cb_ident,

3741

};

3758

};

3742

struct rpc_message msg = {

3759

struct rpc_message msg = {

3743

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],

3760

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],

3744

.rpc_argp = &setclientid,

3761

.rpc_argp = &setclientid,

3745

.rpc_resp = res,

3762

.rpc_resp = res,

3746

.rpc_cred = cred,

3763

.rpc_cred = cred,

3747

};

3764

};

3748

__be32 *p;

3765

__be32 *p;

3749

int loop = 0;

3766

int loop = 0;

3750

int status;

3767

int status;

3751

3768

3752

p = (__be32*)sc_verifier.data;

3769

p = (__be32*)sc_verifier.data;

3753

*p++ = htonl((u32)clp->cl_boot_time.tv_sec);

3770

*p++ = htonl((u32)clp->cl_boot_time.tv_sec);

3754

*p = htonl((u32)clp->cl_boot_time.tv_nsec);

3771

*p = htonl((u32)clp->cl_boot_time.tv_nsec);

3755

3772

3756

for(;;) {

3773

for(;;) {

3757

setclientid.sc_name_len = scnprintf(setclientid.sc_name,

3774

setclientid.sc_name_len = scnprintf(setclientid.sc_name,

3758

sizeof(setclientid.sc_name), "%s/%s %s %s %u",

3775

sizeof(setclientid.sc_name), "%s/%s %s %s %u",

3759

clp->cl_ipaddr,

3776

clp->cl_ipaddr,

3760

rpc_peeraddr2str(clp->cl_rpcclient,

3777

rpc_peeraddr2str(clp->cl_rpcclient,

3761

RPC_DISPLAY_ADDR),

3778

RPC_DISPLAY_ADDR),

3762

rpc_peeraddr2str(clp->cl_rpcclient,

3779

rpc_peeraddr2str(clp->cl_rpcclient,

3763

RPC_DISPLAY_PROTO),

3780

RPC_DISPLAY_PROTO),

3764

clp->cl_rpcclient->cl_auth->au_ops->au_name,

3781

clp->cl_rpcclient->cl_auth->au_ops->au_name,

3765

clp->cl_id_uniquifier);

3782

clp->cl_id_uniquifier);

3766

setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,

3783

setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,

3767

sizeof(setclientid.sc_netid),

3784

sizeof(setclientid.sc_netid),

3768

rpc_peeraddr2str(clp->cl_rpcclient,

3785

rpc_peeraddr2str(clp->cl_rpcclient,

3769

RPC_DISPLAY_NETID));

3786

RPC_DISPLAY_NETID));

3770

setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,

3787

setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,

3771

sizeof(setclientid.sc_uaddr), "%s.%u.%u",

3788

sizeof(setclientid.sc_uaddr), "%s.%u.%u",

3772

clp->cl_ipaddr, port >> 8, port & 255);

3789

clp->cl_ipaddr, port >> 8, port & 255);

3773

3790

3774

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

3791

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

3775

if (status != -NFS4ERR_CLID_INUSE)

3792

if (status != -NFS4ERR_CLID_INUSE)

3776

break;

3793

break;

3777

if (loop != 0) {

3794

if (loop != 0) {

3778

++clp->cl_id_uniquifier;

3795

++clp->cl_id_uniquifier;

3779

break;

3796

break;

3780

}

3797

}

3781

++loop;

3798

++loop;

3782

ssleep(clp->cl_lease_time / HZ + 1);

3799

ssleep(clp->cl_lease_time / HZ + 1);

3783

}

3800

}

3784

return status;

3801

return status;

3785

}

3802

}

3786

3803

3787

int nfs4_proc_setclientid_confirm(struct nfs_client *clp,

3804

int nfs4_proc_setclientid_confirm(struct nfs_client *clp,

3788

struct nfs4_setclientid_res *arg,

3805

struct nfs4_setclientid_res *arg,

3789

struct rpc_cred *cred)

3806

struct rpc_cred *cred)

3790

{

3807

{

3791

struct nfs_fsinfo fsinfo;

3808

struct nfs_fsinfo fsinfo;

3792

struct rpc_message msg = {

3809

struct rpc_message msg = {

3793

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],

3810

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],

3794

.rpc_argp = arg,

3811

.rpc_argp = arg,

3795

.rpc_resp = &fsinfo,

3812

.rpc_resp = &fsinfo,

3796

.rpc_cred = cred,

3813

.rpc_cred = cred,

3797

};

3814

};

3798

unsigned long now;

3815

unsigned long now;

3799

int status;

3816

int status;

3800

3817

3801

now = jiffies;

3818

now = jiffies;

3802

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

3819

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

3803

if (status == 0) {

3820

if (status == 0) {

3804

spin_lock(&clp->cl_lock);

3821

spin_lock(&clp->cl_lock);

3805

clp->cl_lease_time = fsinfo.lease_time * HZ;

3822

clp->cl_lease_time = fsinfo.lease_time * HZ;

3806

clp->cl_last_renewal = now;

3823

clp->cl_last_renewal = now;

3807

spin_unlock(&clp->cl_lock);

3824

spin_unlock(&clp->cl_lock);

3808

}

3825

}

3809

return status;

3826

return status;

3810

}

3827

}

3811

3828

3812

struct nfs4_delegreturndata {

3829

struct nfs4_delegreturndata {

3813

struct nfs4_delegreturnargs args;

3830

struct nfs4_delegreturnargs args;

3814

struct nfs4_delegreturnres res;

3831

struct nfs4_delegreturnres res;

3815

struct nfs_fh fh;

3832

struct nfs_fh fh;

3816

nfs4_stateid stateid;

3833

nfs4_stateid stateid;

3817

unsigned long timestamp;

3834

unsigned long timestamp;

3818

struct nfs_fattr fattr;

3835

struct nfs_fattr fattr;

3819

int rpc_status;

3836

int rpc_status;

3820

};

3837

};

3821

3838

3822

static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)

3839

static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)

3823

{

3840

{

3824

struct nfs4_delegreturndata *data = calldata;

3841

struct nfs4_delegreturndata *data = calldata;

3825

3842

3826

if (!nfs4_sequence_done(task, &data->res.seq_res))

3843

if (!nfs4_sequence_done(task, &data->res.seq_res))

3827

return;

3844

return;

3828

3845

3829

switch (task->tk_status) {

3846

switch (task->tk_status) {

3830

case -NFS4ERR_STALE_STATEID:

3847

case -NFS4ERR_STALE_STATEID:

3831

case -NFS4ERR_EXPIRED:

3848

case -NFS4ERR_EXPIRED:

3832

case 0:

3849

case 0:

3833

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

3850

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

3834

break;

3851

break;

3835

default:

3852

default:

3836

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

3853

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

3837

-EAGAIN) {

3854

-EAGAIN) {

3838

nfs_restart_rpc(task, data->res.server->nfs_client);

3855

nfs_restart_rpc(task, data->res.server->nfs_client);

3839

return;

3856

return;

3840

}

3857

}

3841

}

3858

}

3842

data->rpc_status = task->tk_status;

3859

data->rpc_status = task->tk_status;

3843

}

3860

}

3844

3861

3845

static void nfs4_delegreturn_release(void *calldata)

3862

static void nfs4_delegreturn_release(void *calldata)

3846

{

3863

{

3847

kfree(calldata);

3864

kfree(calldata);

3848

}

3865

}

3849

3866

3850

#if defined(CONFIG_NFS_V4_1)

3867

#if defined(CONFIG_NFS_V4_1)

3851

static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)

3868

static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)

3852

{

3869

{

3853

struct nfs4_delegreturndata *d_data;

3870

struct nfs4_delegreturndata *d_data;

3854

3871

3855

d_data = (struct nfs4_delegreturndata *)data;

3872

d_data = (struct nfs4_delegreturndata *)data;

3856

3873

3857

if (nfs4_setup_sequence(d_data->res.server,

3874

if (nfs4_setup_sequence(d_data->res.server,

3858

&d_data->args.seq_args,

3875

&d_data->args.seq_args,

3859

&d_data->res.seq_res, 1, task))

3876

&d_data->res.seq_res, 1, task))

3860

return;

3877

return;

3861

rpc_call_start(task);

3878

rpc_call_start(task);

3862

}

3879

}

3863

#endif /* CONFIG_NFS_V4_1 */

3880

#endif /* CONFIG_NFS_V4_1 */

3864

3881

3865

static const struct rpc_call_ops nfs4_delegreturn_ops = {

3882

static const struct rpc_call_ops nfs4_delegreturn_ops = {

3866

#if defined(CONFIG_NFS_V4_1)

3883

#if defined(CONFIG_NFS_V4_1)

3867

.rpc_call_prepare = nfs4_delegreturn_prepare,

3884

.rpc_call_prepare = nfs4_delegreturn_prepare,

3868

#endif /* CONFIG_NFS_V4_1 */

3885

#endif /* CONFIG_NFS_V4_1 */

3869

.rpc_call_done = nfs4_delegreturn_done,

3886

.rpc_call_done = nfs4_delegreturn_done,

3870

.rpc_release = nfs4_delegreturn_release,

3887

.rpc_release = nfs4_delegreturn_release,

3871

};

3888

};

3872

3889

3873

static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)

3890

static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)

3874

{

3891

{

3875

struct nfs4_delegreturndata *data;

3892

struct nfs4_delegreturndata *data;

3876

struct nfs_server *server = NFS_SERVER(inode);

3893

struct nfs_server *server = NFS_SERVER(inode);

3877

struct rpc_task *task;

3894

struct rpc_task *task;

3878

struct rpc_message msg = {

3895

struct rpc_message msg = {

3879

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],

3896

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],

3880

.rpc_cred = cred,

3897

.rpc_cred = cred,

3881

};

3898

};

3882

struct rpc_task_setup task_setup_data = {

3899

struct rpc_task_setup task_setup_data = {

3883

.rpc_client = server->client,

3900

.rpc_client = server->client,

3884

.rpc_message = &msg,

3901

.rpc_message = &msg,

3885

.callback_ops = &nfs4_delegreturn_ops,

3902

.callback_ops = &nfs4_delegreturn_ops,

3886

.flags = RPC_TASK_ASYNC,

3903

.flags = RPC_TASK_ASYNC,

3887

};

3904

};

3888

int status = 0;

3905

int status = 0;

3889

3906

3890

data = kzalloc(sizeof(*data), GFP_NOFS);

3907

data = kzalloc(sizeof(*data), GFP_NOFS);

3891

if (data == NULL)

3908

if (data == NULL)

3892

return -ENOMEM;

3909

return -ENOMEM;

3893

data->args.fhandle = &data->fh;

3910

data->args.fhandle = &data->fh;

3894

data->args.stateid = &data->stateid;

3911

data->args.stateid = &data->stateid;

3895

data->args.bitmask = server->attr_bitmask;

3912

data->args.bitmask = server->attr_bitmask;

3896

nfs_copy_fh(&data->fh, NFS_FH(inode));

3913

nfs_copy_fh(&data->fh, NFS_FH(inode));

3897

memcpy(&data->stateid, stateid, sizeof(data->stateid));

3914

memcpy(&data->stateid, stateid, sizeof(data->stateid));

3898

data->res.fattr = &data->fattr;

3915

data->res.fattr = &data->fattr;

3899

data->res.server = server;

3916

data->res.server = server;

3900

nfs_fattr_init(data->res.fattr);

3917

nfs_fattr_init(data->res.fattr);

3901

data->timestamp = jiffies;

3918

data->timestamp = jiffies;

3902

data->rpc_status = 0;

3919

data->rpc_status = 0;

3903

3920

3904

task_setup_data.callback_data = data;

3921

task_setup_data.callback_data = data;

3905

msg.rpc_argp = &data->args;

3922

msg.rpc_argp = &data->args;

3906

msg.rpc_resp = &data->res;

3923

msg.rpc_resp = &data->res;

3907

task = rpc_run_task(&task_setup_data);

3924

task = rpc_run_task(&task_setup_data);

3908

if (IS_ERR(task))

3925

if (IS_ERR(task))

3909

return PTR_ERR(task);

3926

return PTR_ERR(task);

3910

if (!issync)

3927

if (!issync)

3911

goto out;

3928

goto out;

3912

status = nfs4_wait_for_completion_rpc_task(task);

3929

status = nfs4_wait_for_completion_rpc_task(task);

3913

if (status != 0)

3930

if (status != 0)

3914

goto out;

3931

goto out;

3915

status = data->rpc_status;

3932

status = data->rpc_status;

3916

if (status != 0)

3933

if (status != 0)

3917

goto out;

3934

goto out;

3918

nfs_refresh_inode(inode, &data->fattr);

3935

nfs_refresh_inode(inode, &data->fattr);

3919

out:

3936

out:

3920

rpc_put_task(task);

3937

rpc_put_task(task);

3921

return status;

3938

return status;

3922

}

3939

}

3923

3940

3924

int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)

3941

int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)

3925

{

3942

{

3926

struct nfs_server *server = NFS_SERVER(inode);

3943

struct nfs_server *server = NFS_SERVER(inode);

3927

struct nfs4_exception exception = { };

3944

struct nfs4_exception exception = { };

3928

int err;

3945

int err;

3929

do {

3946

do {

3930

err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);

3947

err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);

3931

switch (err) {

3948

switch (err) {

3932

case -NFS4ERR_STALE_STATEID:

3949

case -NFS4ERR_STALE_STATEID:

3933

case -NFS4ERR_EXPIRED:

3950

case -NFS4ERR_EXPIRED:

3934

case 0:

3951

case 0:

3935

return 0;

3952

return 0;

3936

}

3953

}

3937

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

3954

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

3938

} while (exception.retry);

3955

} while (exception.retry);

3939

return err;

3956

return err;

3940

}

3957

}

3941

3958

3942

#define NFS4_LOCK_MINTIMEOUT (1 * HZ)

3959

#define NFS4_LOCK_MINTIMEOUT (1 * HZ)

3943

#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)

3960

#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)

3944

3961

3945

/*

3962

/*

3946

* sleep, with exponential backoff, and retry the LOCK operation.

3963

* sleep, with exponential backoff, and retry the LOCK operation.

3947

*/

3964

*/

3948

static unsigned long

3965

static unsigned long

3949

nfs4_set_lock_task_retry(unsigned long timeout)

3966

nfs4_set_lock_task_retry(unsigned long timeout)

3950

{

3967

{

3951

schedule_timeout_killable(timeout);

3968

schedule_timeout_killable(timeout);

3952

timeout <<= 1;

3969

timeout <<= 1;

3953

if (timeout > NFS4_LOCK_MAXTIMEOUT)

3970

if (timeout > NFS4_LOCK_MAXTIMEOUT)

3954

return NFS4_LOCK_MAXTIMEOUT;

3971

return NFS4_LOCK_MAXTIMEOUT;

3955

return timeout;

3972

return timeout;

3956

}

3973

}

3957

3974

3958

static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)

3975

static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)

3959

{

3976

{

3960

struct inode *inode = state->inode;

3977

struct inode *inode = state->inode;

3961

struct nfs_server *server = NFS_SERVER(inode);

3978

struct nfs_server *server = NFS_SERVER(inode);

3962

struct nfs_client *clp = server->nfs_client;

3979

struct nfs_client *clp = server->nfs_client;

3963

struct nfs_lockt_args arg = {

3980

struct nfs_lockt_args arg = {

3964

.fh = NFS_FH(inode),

3981

.fh = NFS_FH(inode),

3965

.fl = request,

3982

.fl = request,

3966

};

3983

};

3967

struct nfs_lockt_res res = {

3984

struct nfs_lockt_res res = {

3968

.denied = request,

3985

.denied = request,

3969

};

3986

};

3970

struct rpc_message msg = {

3987

struct rpc_message msg = {

3971

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],

3988

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],

3972

.rpc_argp = &arg,

3989

.rpc_argp = &arg,

3973

.rpc_resp = &res,

3990

.rpc_resp = &res,

3974

.rpc_cred = state->owner->so_cred,

3991

.rpc_cred = state->owner->so_cred,

3975

};

3992

};

3976

struct nfs4_lock_state *lsp;

3993

struct nfs4_lock_state *lsp;

3977

int status;

3994

int status;

3978

3995

3979

arg.lock_owner.clientid = clp->cl_clientid;

3996

arg.lock_owner.clientid = clp->cl_clientid;

3980

status = nfs4_set_lock_state(state, request);

3997

status = nfs4_set_lock_state(state, request);

3981

if (status != 0)

3998

if (status != 0)

3982

goto out;

3999

goto out;

3983

lsp = request->fl_u.nfs4_fl.owner;

4000

lsp = request->fl_u.nfs4_fl.owner;

3984

arg.lock_owner.id = lsp->ls_id.id;

4001

arg.lock_owner.id = lsp->ls_id.id;

3985

arg.lock_owner.s_dev = server->s_dev;

4002

arg.lock_owner.s_dev = server->s_dev;

3986

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

4003

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

3987

switch (status) {

4004

switch (status) {

3988

case 0:

4005

case 0:

3989

request->fl_type = F_UNLCK;

4006

request->fl_type = F_UNLCK;

3990

break;

4007

break;

3991

case -NFS4ERR_DENIED:

4008

case -NFS4ERR_DENIED:

3992

status = 0;

4009

status = 0;

3993

}

4010

}

3994

request->fl_ops->fl_release_private(request);

4011

request->fl_ops->fl_release_private(request);

3995

out:

4012

out:

3996

return status;

4013

return status;

3997

}

4014

}

3998

4015

3999

static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4016

static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4000

{

4017

{

4001

struct nfs4_exception exception = { };

4018

struct nfs4_exception exception = { };

4002

int err;

4019

int err;

4003

4020

4004

do {

4021

do {

4005

err = nfs4_handle_exception(NFS_SERVER(state->inode),

4022

err = nfs4_handle_exception(NFS_SERVER(state->inode),

4006

_nfs4_proc_getlk(state, cmd, request),

4023

_nfs4_proc_getlk(state, cmd, request),

4007

&exception);

4024

&exception);

4008

} while (exception.retry);

4025

} while (exception.retry);

4009

return err;

4026

return err;

4010

}

4027

}

4011

4028

4012

static int do_vfs_lock(struct file *file, struct file_lock *fl)

4029

static int do_vfs_lock(struct file *file, struct file_lock *fl)

4013

{

4030

{

4014

int res = 0;

4031

int res = 0;

4015

switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {

4032

switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {

4016

case FL_POSIX:

4033

case FL_POSIX:

4017

res = posix_lock_file_wait(file, fl);

4034

res = posix_lock_file_wait(file, fl);

4018

break;

4035

break;

4019

case FL_FLOCK:

4036

case FL_FLOCK:

4020

res = flock_lock_file_wait(file, fl);

4037

res = flock_lock_file_wait(file, fl);

4021

break;

4038

break;

4022

default:

4039

default:

4023

BUG();

4040

BUG();

4024

}

4041

}

4025

return res;

4042

return res;

4026

}

4043

}

4027

4044

4028

struct nfs4_unlockdata {

4045

struct nfs4_unlockdata {

4029

struct nfs_locku_args arg;

4046

struct nfs_locku_args arg;

4030

struct nfs_locku_res res;

4047

struct nfs_locku_res res;

4031

struct nfs4_lock_state *lsp;

4048

struct nfs4_lock_state *lsp;

4032

struct nfs_open_context *ctx;

4049

struct nfs_open_context *ctx;

4033

struct file_lock fl;

4050

struct file_lock fl;

4034

const struct nfs_server *server;

4051

const struct nfs_server *server;

4035

unsigned long timestamp;

4052

unsigned long timestamp;

4036

};

4053

};

4037

4054

4038

static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,

4055

static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,

4039

struct nfs_open_context *ctx,

4056

struct nfs_open_context *ctx,

4040

struct nfs4_lock_state *lsp,

4057

struct nfs4_lock_state *lsp,

4041

struct nfs_seqid *seqid)

4058

struct nfs_seqid *seqid)

4042

{

4059

{

4043

struct nfs4_unlockdata *p;

4060

struct nfs4_unlockdata *p;

4044

struct inode *inode = lsp->ls_state->inode;

4061

struct inode *inode = lsp->ls_state->inode;

4045

4062

4046

p = kzalloc(sizeof(*p), GFP_NOFS);

4063

p = kzalloc(sizeof(*p), GFP_NOFS);

4047

if (p == NULL)

4064

if (p == NULL)

4048

return NULL;

4065

return NULL;

4049

p->arg.fh = NFS_FH(inode);

4066

p->arg.fh = NFS_FH(inode);

4050

p->arg.fl = &p->fl;

4067

p->arg.fl = &p->fl;

4051

p->arg.seqid = seqid;

4068

p->arg.seqid = seqid;

4052

p->res.seqid = seqid;

4069

p->res.seqid = seqid;

4053

p->arg.stateid = &lsp->ls_stateid;

4070

p->arg.stateid = &lsp->ls_stateid;

4054

p->lsp = lsp;

4071

p->lsp = lsp;

4055

atomic_inc(&lsp->ls_count);

4072

atomic_inc(&lsp->ls_count);

4056

/* Ensure we don't close file until we're done freeing locks! */

4073

/* Ensure we don't close file until we're done freeing locks! */

4057

p->ctx = get_nfs_open_context(ctx);

4074

p->ctx = get_nfs_open_context(ctx);

4058

memcpy(&p->fl, fl, sizeof(p->fl));

4075

memcpy(&p->fl, fl, sizeof(p->fl));

4059

p->server = NFS_SERVER(inode);

4076

p->server = NFS_SERVER(inode);

4060

return p;

4077

return p;

4061

}

4078

}

4062

4079

4063

static void nfs4_locku_release_calldata(void *data)

4080

static void nfs4_locku_release_calldata(void *data)

4064

{

4081

{

4065

struct nfs4_unlockdata *calldata = data;

4082

struct nfs4_unlockdata *calldata = data;

4066

nfs_free_seqid(calldata->arg.seqid);

4083

nfs_free_seqid(calldata->arg.seqid);

4067

nfs4_put_lock_state(calldata->lsp);

4084

nfs4_put_lock_state(calldata->lsp);

4068

put_nfs_open_context(calldata->ctx);

4085

put_nfs_open_context(calldata->ctx);

4069

kfree(calldata);

4086

kfree(calldata);

4070

}

4087

}

4071

4088

4072

static void nfs4_locku_done(struct rpc_task *task, void *data)

4089

static void nfs4_locku_done(struct rpc_task *task, void *data)

4073

{

4090

{

4074

struct nfs4_unlockdata *calldata = data;

4091

struct nfs4_unlockdata *calldata = data;

4075

4092

4076

if (!nfs4_sequence_done(task, &calldata->res.seq_res))

4093

if (!nfs4_sequence_done(task, &calldata->res.seq_res))

4077

return;

4094

return;

4078

switch (task->tk_status) {

4095

switch (task->tk_status) {

4079

case 0:

4096

case 0:

4080

memcpy(calldata->lsp->ls_stateid.data,

4097

memcpy(calldata->lsp->ls_stateid.data,

4081

calldata->res.stateid.data,

4098

calldata->res.stateid.data,

4082

sizeof(calldata->lsp->ls_stateid.data));

4099

sizeof(calldata->lsp->ls_stateid.data));

4083

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

4100

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

4084

break;

4101

break;

4085

case -NFS4ERR_BAD_STATEID:

4102

case -NFS4ERR_BAD_STATEID:

4086

case -NFS4ERR_OLD_STATEID:

4103

case -NFS4ERR_OLD_STATEID:

4087

case -NFS4ERR_STALE_STATEID:

4104

case -NFS4ERR_STALE_STATEID:

4088

case -NFS4ERR_EXPIRED:

4105

case -NFS4ERR_EXPIRED:

4089

break;

4106

break;

4090

default:

4107

default:

4091

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

4108

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

4092

nfs_restart_rpc(task,

4109

nfs_restart_rpc(task,

4093

calldata->server->nfs_client);

4110

calldata->server->nfs_client);

4094

}

4111

}

4095

}

4112

}

4096

4113

4097

static void nfs4_locku_prepare(struct rpc_task *task, void *data)

4114

static void nfs4_locku_prepare(struct rpc_task *task, void *data)

4098

{

4115

{

4099

struct nfs4_unlockdata *calldata = data;

4116

struct nfs4_unlockdata *calldata = data;

4100

4117

4101

if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)

4118

if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)

4102

return;

4119

return;

4103

if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {

4120

if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {

4104

/* Note: exit _without_ running nfs4_locku_done */

4121

/* Note: exit _without_ running nfs4_locku_done */

4105

task->tk_action = NULL;

4122

task->tk_action = NULL;

4106

return;

4123

return;

4107

}

4124

}

4108

calldata->timestamp = jiffies;

4125

calldata->timestamp = jiffies;

4109

if (nfs4_setup_sequence(calldata->server,

4126

if (nfs4_setup_sequence(calldata->server,

4110

&calldata->arg.seq_args,

4127

&calldata->arg.seq_args,

4111

&calldata->res.seq_res, 1, task))

4128

&calldata->res.seq_res, 1, task))

4112

return;

4129

return;

4113

rpc_call_start(task);

4130

rpc_call_start(task);

4114

}

4131

}

4115

4132

4116

static const struct rpc_call_ops nfs4_locku_ops = {

4133

static const struct rpc_call_ops nfs4_locku_ops = {

4117

.rpc_call_prepare = nfs4_locku_prepare,

4134

.rpc_call_prepare = nfs4_locku_prepare,

4118

.rpc_call_done = nfs4_locku_done,

4135

.rpc_call_done = nfs4_locku_done,

4119

.rpc_release = nfs4_locku_release_calldata,

4136

.rpc_release = nfs4_locku_release_calldata,

4120

};

4137

};

4121

4138

4122

static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,

4139

static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,

4123

struct nfs_open_context *ctx,

4140

struct nfs_open_context *ctx,

4124

struct nfs4_lock_state *lsp,

4141

struct nfs4_lock_state *lsp,

4125

struct nfs_seqid *seqid)

4142

struct nfs_seqid *seqid)

4126

{

4143

{

4127

struct nfs4_unlockdata *data;

4144

struct nfs4_unlockdata *data;

4128

struct rpc_message msg = {

4145

struct rpc_message msg = {

4129

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],

4146

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],

4130

.rpc_cred = ctx->cred,

4147

.rpc_cred = ctx->cred,

4131

};

4148

};

4132

struct rpc_task_setup task_setup_data = {

4149

struct rpc_task_setup task_setup_data = {

4133

.rpc_client = NFS_CLIENT(lsp->ls_state->inode),

4150

.rpc_client = NFS_CLIENT(lsp->ls_state->inode),

4134

.rpc_message = &msg,

4151

.rpc_message = &msg,

4135

.callback_ops = &nfs4_locku_ops,

4152

.callback_ops = &nfs4_locku_ops,

4136

.workqueue = nfsiod_workqueue,

4153

.workqueue = nfsiod_workqueue,

4137

.flags = RPC_TASK_ASYNC,

4154

.flags = RPC_TASK_ASYNC,

4138

};

4155

};

4139

4156

4140

/* Ensure this is an unlock - when canceling a lock, the

4157

/* Ensure this is an unlock - when canceling a lock, the

4141

* canceled lock is passed in, and it won't be an unlock.

4158

* canceled lock is passed in, and it won't be an unlock.

4142

*/

4159

*/

4143

fl->fl_type = F_UNLCK;

4160

fl->fl_type = F_UNLCK;

4144

4161

4145

data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);

4162

data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);

4146

if (data == NULL) {

4163

if (data == NULL) {

4147

nfs_free_seqid(seqid);

4164

nfs_free_seqid(seqid);

4148

return ERR_PTR(-ENOMEM);

4165

return ERR_PTR(-ENOMEM);

4149

}

4166

}

4150

4167

4151

msg.rpc_argp = &data->arg;

4168

msg.rpc_argp = &data->arg;

4152

msg.rpc_resp = &data->res;

4169

msg.rpc_resp = &data->res;

4153

task_setup_data.callback_data = data;

4170

task_setup_data.callback_data = data;

4154

return rpc_run_task(&task_setup_data);

4171

return rpc_run_task(&task_setup_data);

4155

}

4172

}

4156

4173

4157

static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)

4174

static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)

4158

{

4175

{

4159

struct nfs_inode *nfsi = NFS_I(state->inode);

4176

struct nfs_inode *nfsi = NFS_I(state->inode);

4160

struct nfs_seqid *seqid;

4177

struct nfs_seqid *seqid;

4161

struct nfs4_lock_state *lsp;

4178

struct nfs4_lock_state *lsp;

4162

struct rpc_task *task;

4179

struct rpc_task *task;

4163

int status = 0;

4180

int status = 0;

4164

unsigned char fl_flags = request->fl_flags;

4181

unsigned char fl_flags = request->fl_flags;

4165

4182

4166

status = nfs4_set_lock_state(state, request);

4183

status = nfs4_set_lock_state(state, request);

4167

/* Unlock _before_ we do the RPC call */

4184

/* Unlock _before_ we do the RPC call */

4168

request->fl_flags |= FL_EXISTS;

4185

request->fl_flags |= FL_EXISTS;

4169

down_read(&nfsi->rwsem);

4186

down_read(&nfsi->rwsem);

4170

if (do_vfs_lock(request->fl_file, request) == -ENOENT) {

4187

if (do_vfs_lock(request->fl_file, request) == -ENOENT) {

4171

up_read(&nfsi->rwsem);

4188

up_read(&nfsi->rwsem);

4172

goto out;

4189

goto out;

4173

}

4190

}

4174

up_read(&nfsi->rwsem);

4191

up_read(&nfsi->rwsem);

4175

if (status != 0)

4192

if (status != 0)

4176

goto out;

4193

goto out;

4177

/* Is this a delegated lock? */

4194

/* Is this a delegated lock? */

4178

if (test_bit(NFS_DELEGATED_STATE, &state->flags))

4195

if (test_bit(NFS_DELEGATED_STATE, &state->flags))

4179

goto out;

4196

goto out;

4180

lsp = request->fl_u.nfs4_fl.owner;

4197

lsp = request->fl_u.nfs4_fl.owner;

4181

seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);

4198

seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);

4182

status = -ENOMEM;

4199

status = -ENOMEM;

4183

if (seqid == NULL)

4200

if (seqid == NULL)

4184

goto out;

4201

goto out;

4185

task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);

4202

task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);

4186

status = PTR_ERR(task);

4203

status = PTR_ERR(task);

4187

if (IS_ERR(task))

4204

if (IS_ERR(task))

4188

goto out;

4205

goto out;

4189

status = nfs4_wait_for_completion_rpc_task(task);

4206

status = nfs4_wait_for_completion_rpc_task(task);

4190

rpc_put_task(task);

4207

rpc_put_task(task);

4191

out:

4208

out:

4192

request->fl_flags = fl_flags;

4209

request->fl_flags = fl_flags;

4193

return status;

4210

return status;

4194

}

4211

}

4195

4212

4196

struct nfs4_lockdata {

4213

struct nfs4_lockdata {

4197

struct nfs_lock_args arg;

4214

struct nfs_lock_args arg;

4198

struct nfs_lock_res res;

4215

struct nfs_lock_res res;

4199

struct nfs4_lock_state *lsp;

4216

struct nfs4_lock_state *lsp;

4200

struct nfs_open_context *ctx;

4217

struct nfs_open_context *ctx;

4201

struct file_lock fl;

4218

struct file_lock fl;

4202

unsigned long timestamp;

4219

unsigned long timestamp;

4203

int rpc_status;

4220

int rpc_status;

4204

int cancelled;

4221

int cancelled;

4205

struct nfs_server *server;

4222

struct nfs_server *server;

4206

};

4223

};

4207

4224

4208

static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,

4225

static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,

4209

struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,

4226

struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,

4210

gfp_t gfp_mask)

4227

gfp_t gfp_mask)

4211

{

4228

{

4212

struct nfs4_lockdata *p;

4229

struct nfs4_lockdata *p;

4213

struct inode *inode = lsp->ls_state->inode;

4230

struct inode *inode = lsp->ls_state->inode;

4214

struct nfs_server *server = NFS_SERVER(inode);

4231

struct nfs_server *server = NFS_SERVER(inode);

4215

4232

4216

p = kzalloc(sizeof(*p), gfp_mask);

4233

p = kzalloc(sizeof(*p), gfp_mask);

4217

if (p == NULL)

4234

if (p == NULL)

4218

return NULL;

4235

return NULL;

4219

4236

4220

p->arg.fh = NFS_FH(inode);

4237

p->arg.fh = NFS_FH(inode);

4221

p->arg.fl = &p->fl;

4238

p->arg.fl = &p->fl;

4222

p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);

4239

p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);

4223

if (p->arg.open_seqid == NULL)

4240

if (p->arg.open_seqid == NULL)

4224

goto out_free;

4241

goto out_free;

4225

p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);

4242

p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);

4226

if (p->arg.lock_seqid == NULL)

4243

if (p->arg.lock_seqid == NULL)

4227

goto out_free_seqid;

4244

goto out_free_seqid;

4228

p->arg.lock_stateid = &lsp->ls_stateid;

4245

p->arg.lock_stateid = &lsp->ls_stateid;

4229

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

4246

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

4230

p->arg.lock_owner.id = lsp->ls_id.id;

4247

p->arg.lock_owner.id = lsp->ls_id.id;

4231

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

4248

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

4232

p->res.lock_seqid = p->arg.lock_seqid;

4249

p->res.lock_seqid = p->arg.lock_seqid;

4233

p->lsp = lsp;

4250

p->lsp = lsp;

4234

p->server = server;

4251

p->server = server;

4235

atomic_inc(&lsp->ls_count);

4252

atomic_inc(&lsp->ls_count);

4236

p->ctx = get_nfs_open_context(ctx);

4253

p->ctx = get_nfs_open_context(ctx);

4237

memcpy(&p->fl, fl, sizeof(p->fl));

4254

memcpy(&p->fl, fl, sizeof(p->fl));

4238

return p;

4255

return p;

4239

out_free_seqid:

4256

out_free_seqid:

4240

nfs_free_seqid(p->arg.open_seqid);

4257

nfs_free_seqid(p->arg.open_seqid);

4241

out_free:

4258

out_free:

4242

kfree(p);

4259

kfree(p);

4243

return NULL;

4260

return NULL;

4244

}

4261

}

4245

4262

4246

static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)

4263

static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)

4247

{

4264

{

4248

struct nfs4_lockdata *data = calldata;

4265

struct nfs4_lockdata *data = calldata;

4249

struct nfs4_state *state = data->lsp->ls_state;

4266

struct nfs4_state *state = data->lsp->ls_state;

4250

4267

4251

dprintk("%s: begin!\n", __func__);

4268

dprintk("%s: begin!\n", __func__);

4252

if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)

4269

if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)

4253

return;

4270

return;

4254

/* Do we need to do an open_to_lock_owner? */

4271

/* Do we need to do an open_to_lock_owner? */

4255

if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {

4272

if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {

4256

if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0)

4273

if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0)

4257

return;

4274

return;

4258

data->arg.open_stateid = &state->stateid;

4275

data->arg.open_stateid = &state->stateid;

4259

data->arg.new_lock_owner = 1;

4276

data->arg.new_lock_owner = 1;

4260

data->res.open_seqid = data->arg.open_seqid;

4277

data->res.open_seqid = data->arg.open_seqid;

4261

} else

4278

} else

4262

data->arg.new_lock_owner = 0;

4279

data->arg.new_lock_owner = 0;

4263

data->timestamp = jiffies;

4280

data->timestamp = jiffies;

4264

if (nfs4_setup_sequence(data->server,

4281

if (nfs4_setup_sequence(data->server,

4265

&data->arg.seq_args,

4282

&data->arg.seq_args,

4266

&data->res.seq_res, 1, task))

4283

&data->res.seq_res, 1, task))

4267

return;

4284

return;

4268

rpc_call_start(task);

4285

rpc_call_start(task);

4269

dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);

4286

dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);

4270

}

4287

}

4271

4288

4272

static void nfs4_recover_lock_prepare(struct rpc_task *task, void *calldata)

4289

static void nfs4_recover_lock_prepare(struct rpc_task *task, void *calldata)

4273

{

4290

{

4274

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

4291

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

4275

nfs4_lock_prepare(task, calldata);

4292

nfs4_lock_prepare(task, calldata);

4276

}

4293

}

4277

4294

4278

static void nfs4_lock_done(struct rpc_task *task, void *calldata)

4295

static void nfs4_lock_done(struct rpc_task *task, void *calldata)

4279

{

4296

{

4280

struct nfs4_lockdata *data = calldata;

4297

struct nfs4_lockdata *data = calldata;

4281

4298

4282

dprintk("%s: begin!\n", __func__);

4299

dprintk("%s: begin!\n", __func__);

4283

4300

4284

if (!nfs4_sequence_done(task, &data->res.seq_res))

4301

if (!nfs4_sequence_done(task, &data->res.seq_res))

4285

return;

4302

return;

4286

4303

4287

data->rpc_status = task->tk_status;

4304

data->rpc_status = task->tk_status;

4288

if (data->arg.new_lock_owner != 0) {

4305

if (data->arg.new_lock_owner != 0) {

4289

if (data->rpc_status == 0)

4306

if (data->rpc_status == 0)

4290

nfs_confirm_seqid(&data->lsp->ls_seqid, 0);

4307

nfs_confirm_seqid(&data->lsp->ls_seqid, 0);

4291

else

4308

else

4292

goto out;

4309

goto out;

4293

}

4310

}

4294

if (data->rpc_status == 0) {

4311

if (data->rpc_status == 0) {

4295

memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,

4312

memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,

4296

sizeof(data->lsp->ls_stateid.data));

4313

sizeof(data->lsp->ls_stateid.data));

4297

data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;

4314

data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;

4298

renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);

4315

renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);

4299

}

4316

}

4300

out:

4317

out:

4301

dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);

4318

dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);

4302

}

4319

}

4303

4320

4304

static void nfs4_lock_release(void *calldata)

4321

static void nfs4_lock_release(void *calldata)

4305

{

4322

{

4306

struct nfs4_lockdata *data = calldata;

4323

struct nfs4_lockdata *data = calldata;

4307

4324

4308

dprintk("%s: begin!\n", __func__);

4325

dprintk("%s: begin!\n", __func__);

4309

nfs_free_seqid(data->arg.open_seqid);

4326

nfs_free_seqid(data->arg.open_seqid);

4310

if (data->cancelled != 0) {

4327

if (data->cancelled != 0) {

4311

struct rpc_task *task;

4328

struct rpc_task *task;

4312

task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,

4329

task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,

4313

data->arg.lock_seqid);

4330

data->arg.lock_seqid);

4314

if (!IS_ERR(task))

4331

if (!IS_ERR(task))

4315

rpc_put_task_async(task);

4332

rpc_put_task_async(task);

4316

dprintk("%s: cancelling lock!\n", __func__);

4333

dprintk("%s: cancelling lock!\n", __func__);

4317

} else

4334

} else

4318

nfs_free_seqid(data->arg.lock_seqid);

4335

nfs_free_seqid(data->arg.lock_seqid);

4319

nfs4_put_lock_state(data->lsp);

4336

nfs4_put_lock_state(data->lsp);

4320

put_nfs_open_context(data->ctx);

4337

put_nfs_open_context(data->ctx);

4321

kfree(data);

4338

kfree(data);

4322

dprintk("%s: done!\n", __func__);

4339

dprintk("%s: done!\n", __func__);

4323

}

4340

}

4324

4341

4325

static const struct rpc_call_ops nfs4_lock_ops = {

4342

static const struct rpc_call_ops nfs4_lock_ops = {

4326

.rpc_call_prepare = nfs4_lock_prepare,

4343

.rpc_call_prepare = nfs4_lock_prepare,

4327

.rpc_call_done = nfs4_lock_done,

4344

.rpc_call_done = nfs4_lock_done,

4328

.rpc_release = nfs4_lock_release,

4345

.rpc_release = nfs4_lock_release,

4329

};

4346

};

4330

4347

4331

static const struct rpc_call_ops nfs4_recover_lock_ops = {

4348

static const struct rpc_call_ops nfs4_recover_lock_ops = {

4332

.rpc_call_prepare = nfs4_recover_lock_prepare,

4349

.rpc_call_prepare = nfs4_recover_lock_prepare,

4333

.rpc_call_done = nfs4_lock_done,

4350

.rpc_call_done = nfs4_lock_done,

4334

.rpc_release = nfs4_lock_release,

4351

.rpc_release = nfs4_lock_release,

4335

};

4352

};

4336

4353

4337

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

4354

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

4338

{

4355

{

4339

switch (error) {

4356

switch (error) {

4340

case -NFS4ERR_ADMIN_REVOKED:

4357

case -NFS4ERR_ADMIN_REVOKED:

4341

case -NFS4ERR_BAD_STATEID:

4358

case -NFS4ERR_BAD_STATEID:

4342

lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;

4359

lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;

4343

if (new_lock_owner != 0 ||

4360

if (new_lock_owner != 0 ||

4344

(lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)

4361

(lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)

4345

nfs4_schedule_stateid_recovery(server, lsp->ls_state);

4362

nfs4_schedule_stateid_recovery(server, lsp->ls_state);

4346

break;

4363

break;

4347

case -NFS4ERR_STALE_STATEID:

4364

case -NFS4ERR_STALE_STATEID:

4348

lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;

4365

lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;

4349

case -NFS4ERR_EXPIRED:

4366

case -NFS4ERR_EXPIRED:

4350

nfs4_schedule_lease_recovery(server->nfs_client);

4367

nfs4_schedule_lease_recovery(server->nfs_client);

4351

};

4368

};

4352

}

4369

}

4353

4370

4354

static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)

4371

static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)

4355

{

4372

{

4356

struct nfs4_lockdata *data;

4373

struct nfs4_lockdata *data;

4357

struct rpc_task *task;

4374

struct rpc_task *task;

4358

struct rpc_message msg = {

4375

struct rpc_message msg = {

4359

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],

4376

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],

4360

.rpc_cred = state->owner->so_cred,

4377

.rpc_cred = state->owner->so_cred,

4361

};

4378

};

4362

struct rpc_task_setup task_setup_data = {

4379

struct rpc_task_setup task_setup_data = {

4363

.rpc_client = NFS_CLIENT(state->inode),

4380

.rpc_client = NFS_CLIENT(state->inode),

4364

.rpc_message = &msg,

4381

.rpc_message = &msg,

4365

.callback_ops = &nfs4_lock_ops,

4382

.callback_ops = &nfs4_lock_ops,

4366

.workqueue = nfsiod_workqueue,

4383

.workqueue = nfsiod_workqueue,

4367

.flags = RPC_TASK_ASYNC,

4384

.flags = RPC_TASK_ASYNC,

4368

};

4385

};

4369

int ret;

4386

int ret;

4370

4387

4371

dprintk("%s: begin!\n", __func__);

4388

dprintk("%s: begin!\n", __func__);

4372

data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),

4389

data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),

4373

fl->fl_u.nfs4_fl.owner,

4390

fl->fl_u.nfs4_fl.owner,

4374

recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);

4391

recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);

4375

if (data == NULL)

4392

if (data == NULL)

4376

return -ENOMEM;

4393

return -ENOMEM;

4377

if (IS_SETLKW(cmd))

4394

if (IS_SETLKW(cmd))

4378

data->arg.block = 1;

4395

data->arg.block = 1;

4379

if (recovery_type > NFS_LOCK_NEW) {

4396

if (recovery_type > NFS_LOCK_NEW) {

4380

if (recovery_type == NFS_LOCK_RECLAIM)

4397

if (recovery_type == NFS_LOCK_RECLAIM)

4381

data->arg.reclaim = NFS_LOCK_RECLAIM;

4398

data->arg.reclaim = NFS_LOCK_RECLAIM;

4382

task_setup_data.callback_ops = &nfs4_recover_lock_ops;

4399

task_setup_data.callback_ops = &nfs4_recover_lock_ops;

4383

}

4400

}

4384

msg.rpc_argp = &data->arg;

4401

msg.rpc_argp = &data->arg;

4385

msg.rpc_resp = &data->res;

4402

msg.rpc_resp = &data->res;

4386

task_setup_data.callback_data = data;

4403

task_setup_data.callback_data = data;

4387

task = rpc_run_task(&task_setup_data);

4404

task = rpc_run_task(&task_setup_data);

4388

if (IS_ERR(task))

4405

if (IS_ERR(task))

4389

return PTR_ERR(task);

4406

return PTR_ERR(task);

4390

ret = nfs4_wait_for_completion_rpc_task(task);

4407

ret = nfs4_wait_for_completion_rpc_task(task);

4391

if (ret == 0) {

4408

if (ret == 0) {

4392

ret = data->rpc_status;

4409

ret = data->rpc_status;

4393

if (ret)

4410

if (ret)

4394

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

4411

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

4395

data->arg.new_lock_owner, ret);

4412

data->arg.new_lock_owner, ret);

4396

} else

4413

} else

4397

data->cancelled = 1;

4414

data->cancelled = 1;

4398

rpc_put_task(task);

4415

rpc_put_task(task);

4399

dprintk("%s: done, ret = %d!\n", __func__, ret);

4416

dprintk("%s: done, ret = %d!\n", __func__, ret);

4400

return ret;

4417

return ret;

4401

}

4418

}

4402

4419

4403

static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)

4420

static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)

4404

{

4421

{

4405

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

4422

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

4406

struct nfs4_exception exception = { };

4423

struct nfs4_exception exception = { };

4407

int err;

4424

int err;

4408

4425

4409

do {

4426

do {

4410

/* Cache the lock if possible... */

4427

/* Cache the lock if possible... */

4411

if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)

4428

if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)

4412

return 0;

4429

return 0;

4413

err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);

4430

err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);

4414

if (err != -NFS4ERR_DELAY)

4431

if (err != -NFS4ERR_DELAY)

4415

break;

4432

break;

4416

nfs4_handle_exception(server, err, &exception);

4433

nfs4_handle_exception(server, err, &exception);

4417

} while (exception.retry);

4434

} while (exception.retry);

4418

return err;

4435

return err;

4419

}

4436

}

4420

4437

4421

static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)

4438

static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)

4422

{

4439

{

4423

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

4440

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

4424

struct nfs4_exception exception = { };

4441

struct nfs4_exception exception = { };

4425

int err;

4442

int err;

4426

4443

4427

err = nfs4_set_lock_state(state, request);

4444

err = nfs4_set_lock_state(state, request);

4428

if (err != 0)

4445

if (err != 0)

4429

return err;

4446

return err;

4430

do {

4447

do {

4431

if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)

4448

if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)

4432

return 0;

4449

return 0;

4433

err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);

4450

err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);

4434

switch (err) {

4451

switch (err) {

4435

default:

4452

default:

4436

goto out;

4453

goto out;

4437

case -NFS4ERR_GRACE:

4454

case -NFS4ERR_GRACE:

4438

case -NFS4ERR_DELAY:

4455

case -NFS4ERR_DELAY:

4439

nfs4_handle_exception(server, err, &exception);

4456

nfs4_handle_exception(server, err, &exception);

4440

err = 0;

4457

err = 0;

4441

}

4458

}

4442

} while (exception.retry);

4459

} while (exception.retry);

4443

out:

4460

out:

4444

return err;

4461

return err;

4445

}

4462

}

4446

4463

4464

#if defined(CONFIG_NFS_V4_1)

4465

static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)

4466

{

4467

int status;

4468

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

4469

4470

status = nfs41_test_stateid(server, state);

4471

if (status == NFS_OK)

4472

return 0;

4473

nfs41_free_stateid(server, state);

4474

return nfs4_lock_expired(state, request);

4475

}

4476

#endif

4477

4447

static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4478

static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4448

{

4479

{

4449

struct nfs_inode *nfsi = NFS_I(state->inode);

4480

struct nfs_inode *nfsi = NFS_I(state->inode);

4450

unsigned char fl_flags = request->fl_flags;

4481

unsigned char fl_flags = request->fl_flags;

4451

int status = -ENOLCK;

4482

int status = -ENOLCK;

4452

4483

4453

if ((fl_flags & FL_POSIX) &&

4484

if ((fl_flags & FL_POSIX) &&

4454

!test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))

4485

!test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))

4455

goto out;

4486

goto out;

4456

/* Is this a delegated open? */

4487

/* Is this a delegated open? */

4457

status = nfs4_set_lock_state(state, request);

4488

status = nfs4_set_lock_state(state, request);

4458

if (status != 0)

4489

if (status != 0)

4459

goto out;

4490

goto out;

4460

request->fl_flags |= FL_ACCESS;

4491

request->fl_flags |= FL_ACCESS;

4461

status = do_vfs_lock(request->fl_file, request);

4492

status = do_vfs_lock(request->fl_file, request);

4462

if (status < 0)

4493

if (status < 0)

4463

goto out;

4494

goto out;

4464

down_read(&nfsi->rwsem);

4495

down_read(&nfsi->rwsem);

4465

if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {

4496

if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {

4466

/* Yes: cache locks! */

4497

/* Yes: cache locks! */

4467

/* ...but avoid races with delegation recall... */

4498

/* ...but avoid races with delegation recall... */

4468

request->fl_flags = fl_flags & ~FL_SLEEP;

4499

request->fl_flags = fl_flags & ~FL_SLEEP;

4469

status = do_vfs_lock(request->fl_file, request);

4500

status = do_vfs_lock(request->fl_file, request);

4470

goto out_unlock;

4501

goto out_unlock;

4471

}

4502

}

4472

status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);

4503

status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);

4473

if (status != 0)

4504

if (status != 0)

4474

goto out_unlock;

4505

goto out_unlock;

4475

/* Note: we always want to sleep here! */

4506

/* Note: we always want to sleep here! */

4476

request->fl_flags = fl_flags | FL_SLEEP;

4507

request->fl_flags = fl_flags | FL_SLEEP;

4477

if (do_vfs_lock(request->fl_file, request) < 0)

4508

if (do_vfs_lock(request->fl_file, request) < 0)

4478

printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);

4509

printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);

4479

out_unlock:

4510

out_unlock:

4480

up_read(&nfsi->rwsem);

4511

up_read(&nfsi->rwsem);

4481

out:

4512

out:

4482

request->fl_flags = fl_flags;

4513

request->fl_flags = fl_flags;

4483

return status;

4514

return status;

4484

}

4515

}

4485

4516

4486

static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4517

static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)

4487

{

4518

{

4488

struct nfs4_exception exception = { };

4519

struct nfs4_exception exception = { };

4489

int err;

4520

int err;

4490

4521

4491

do {

4522

do {

4492

err = _nfs4_proc_setlk(state, cmd, request);

4523

err = _nfs4_proc_setlk(state, cmd, request);

4493

if (err == -NFS4ERR_DENIED)

4524

if (err == -NFS4ERR_DENIED)

4494

err = -EAGAIN;

4525

err = -EAGAIN;

4495

err = nfs4_handle_exception(NFS_SERVER(state->inode),

4526

err = nfs4_handle_exception(NFS_SERVER(state->inode),

4496

err, &exception);

4527

err, &exception);

4497

} while (exception.retry);

4528

} while (exception.retry);

4498

return err;

4529

return err;

4499

}

4530

}

4500

4531

4501

static int

4532

static int

4502

nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)

4533

nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)

4503

{

4534

{

4504

struct nfs_open_context *ctx;

4535

struct nfs_open_context *ctx;

4505

struct nfs4_state *state;

4536

struct nfs4_state *state;

4506

unsigned long timeout = NFS4_LOCK_MINTIMEOUT;

4537

unsigned long timeout = NFS4_LOCK_MINTIMEOUT;

4507

int status;

4538

int status;

4508

4539

4509

/* verify open state */

4540

/* verify open state */

4510

ctx = nfs_file_open_context(filp);

4541

ctx = nfs_file_open_context(filp);

4511

state = ctx->state;

4542

state = ctx->state;

4512

4543

4513

if (request->fl_start < 0 || request->fl_end < 0)

4544

if (request->fl_start < 0 || request->fl_end < 0)

4514

return -EINVAL;

4545

return -EINVAL;

4515

4546

4516

if (IS_GETLK(cmd)) {

4547

if (IS_GETLK(cmd)) {

4517

if (state != NULL)

4548

if (state != NULL)

4518

return nfs4_proc_getlk(state, F_GETLK, request);

4549

return nfs4_proc_getlk(state, F_GETLK, request);

4519

return 0;

4550

return 0;

4520

}

4551

}

4521

4552

4522

if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))

4553

if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))

4523

return -EINVAL;

4554

return -EINVAL;

4524

4555

4525

if (request->fl_type == F_UNLCK) {

4556

if (request->fl_type == F_UNLCK) {

4526

if (state != NULL)

4557

if (state != NULL)

4527

return nfs4_proc_unlck(state, cmd, request);

4558

return nfs4_proc_unlck(state, cmd, request);

4528

return 0;

4559

return 0;

4529

}

4560

}

4530

4561

4531

if (state == NULL)

4562

if (state == NULL)

4532

return -ENOLCK;

4563

return -ENOLCK;

4533

do {

4564

do {

4534

status = nfs4_proc_setlk(state, cmd, request);

4565

status = nfs4_proc_setlk(state, cmd, request);

4535

if ((status != -EAGAIN) || IS_SETLK(cmd))

4566

if ((status != -EAGAIN) || IS_SETLK(cmd))

4536

break;

4567

break;

4537

timeout = nfs4_set_lock_task_retry(timeout);

4568

timeout = nfs4_set_lock_task_retry(timeout);

4538

status = -ERESTARTSYS;

4569

status = -ERESTARTSYS;

4539

if (signalled())

4570

if (signalled())

4540

break;

4571

break;

4541

} while(status < 0);

4572

} while(status < 0);

4542

return status;

4573

return status;

4543

}

4574

}

4544

4575

4545

int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)

4576

int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)

4546

{

4577

{

4547

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

4578

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

4548

struct nfs4_exception exception = { };

4579

struct nfs4_exception exception = { };

4549

int err;

4580

int err;

4550

4581

4551

err = nfs4_set_lock_state(state, fl);

4582

err = nfs4_set_lock_state(state, fl);

4552

if (err != 0)

4583

if (err != 0)

4553

goto out;

4584

goto out;

4554

do {

4585

do {

4555

err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);

4586

err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);

4556

switch (err) {

4587

switch (err) {

4557

default:

4588

default:

4558

printk(KERN_ERR "%s: unhandled error %d.\n",

4589

printk(KERN_ERR "%s: unhandled error %d.\n",

4559

__func__, err);

4590

__func__, err);

4560

case 0:

4591

case 0:

4561

case -ESTALE:

4592

case -ESTALE:

4562

goto out;

4593

goto out;

4563

case -NFS4ERR_EXPIRED:

4594

case -NFS4ERR_EXPIRED:

4564

nfs4_schedule_stateid_recovery(server, state);

4595

nfs4_schedule_stateid_recovery(server, state);

4565

case -NFS4ERR_STALE_CLIENTID:

4596

case -NFS4ERR_STALE_CLIENTID:

4566

case -NFS4ERR_STALE_STATEID:

4597

case -NFS4ERR_STALE_STATEID:

4567

nfs4_schedule_lease_recovery(server->nfs_client);

4598

nfs4_schedule_lease_recovery(server->nfs_client);

4568

goto out;

4599

goto out;

4569

case -NFS4ERR_BADSESSION:

4600

case -NFS4ERR_BADSESSION:

4570

case -NFS4ERR_BADSLOT:

4601

case -NFS4ERR_BADSLOT:

4571

case -NFS4ERR_BAD_HIGH_SLOT:

4602

case -NFS4ERR_BAD_HIGH_SLOT:

4572

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

4603

case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:

4573

case -NFS4ERR_DEADSESSION:

4604

case -NFS4ERR_DEADSESSION:

4574

nfs4_schedule_session_recovery(server->nfs_client->cl_session);

4605

nfs4_schedule_session_recovery(server->nfs_client->cl_session);

4575

goto out;

4606

goto out;

4576

case -ERESTARTSYS:

4607

case -ERESTARTSYS:

4577

/*

4608

/*

4578

* The show must go on: exit, but mark the

4609

* The show must go on: exit, but mark the

4579

* stateid as needing recovery.

4610

* stateid as needing recovery.

4580

*/

4611

*/

4581

case -NFS4ERR_ADMIN_REVOKED:

4612

case -NFS4ERR_ADMIN_REVOKED:

4582

case -NFS4ERR_BAD_STATEID:

4613

case -NFS4ERR_BAD_STATEID:

4583

case -NFS4ERR_OPENMODE:

4614

case -NFS4ERR_OPENMODE:

4584

nfs4_schedule_stateid_recovery(server, state);

4615

nfs4_schedule_stateid_recovery(server, state);

4585

err = 0;

4616

err = 0;

4586

goto out;

4617

goto out;

4587

case -EKEYEXPIRED:

4618

case -EKEYEXPIRED:

4588

/*

4619

/*

4589

* User RPCSEC_GSS context has expired.

4620

* User RPCSEC_GSS context has expired.

4590

* We cannot recover this stateid now, so

4621

* We cannot recover this stateid now, so

4591

* skip it and allow recovery thread to

4622

* skip it and allow recovery thread to

4592

* proceed.

4623

* proceed.

4593

*/

4624

*/

4594

err = 0;

4625

err = 0;

4595

goto out;

4626

goto out;

4596

case -ENOMEM:

4627

case -ENOMEM:

4597

case -NFS4ERR_DENIED:

4628

case -NFS4ERR_DENIED:

4598

/* kill_proc(fl->fl_pid, SIGLOST, 1); */

4629

/* kill_proc(fl->fl_pid, SIGLOST, 1); */

4599

err = 0;

4630

err = 0;

4600

goto out;

4631

goto out;

4601

case -NFS4ERR_DELAY:

4632

case -NFS4ERR_DELAY:

4602

break;

4633

break;

4603

}

4634

}

4604

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

4635

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

4605

} while (exception.retry);

4636

} while (exception.retry);

4606

out:

4637

out:

4607

return err;

4638

return err;

4608

}

4639

}

4609

4640

4610

static void nfs4_release_lockowner_release(void *calldata)

4641

static void nfs4_release_lockowner_release(void *calldata)

4611

{

4642

{

4612

kfree(calldata);

4643

kfree(calldata);

4613

}

4644

}

4614

4645

4615

const struct rpc_call_ops nfs4_release_lockowner_ops = {

4646

const struct rpc_call_ops nfs4_release_lockowner_ops = {

4616

.rpc_release = nfs4_release_lockowner_release,

4647

.rpc_release = nfs4_release_lockowner_release,

4617

};

4648

};

4618

4649

4619

void nfs4_release_lockowner(const struct nfs4_lock_state *lsp)

4650

void nfs4_release_lockowner(const struct nfs4_lock_state *lsp)

4620

{

4651

{

4621

struct nfs_server *server = lsp->ls_state->owner->so_server;

4652

struct nfs_server *server = lsp->ls_state->owner->so_server;

4622

struct nfs_release_lockowner_args *args;

4653

struct nfs_release_lockowner_args *args;

4623

struct rpc_message msg = {

4654

struct rpc_message msg = {

4624

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],

4655

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],

4625

};

4656

};

4626

4657

4627

if (server->nfs_client->cl_mvops->minor_version != 0)

4658

if (server->nfs_client->cl_mvops->minor_version != 0)

4628

return;

4659

return;

4629

args = kmalloc(sizeof(*args), GFP_NOFS);

4660

args = kmalloc(sizeof(*args), GFP_NOFS);

4630

if (!args)

4661

if (!args)

4631

return;

4662

return;

4632

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

4663

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

4633

args->lock_owner.id = lsp->ls_id.id;

4664

args->lock_owner.id = lsp->ls_id.id;

4634

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

4665

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

4635

msg.rpc_argp = args;

4666

msg.rpc_argp = args;

4636

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

4667

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

4637

}

4668

}

4638

4669

4639

#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"

4670

#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"

4640

4671

4641

static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,

4672

static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,

4642

const void *buf, size_t buflen,

4673

const void *buf, size_t buflen,

4643

int flags, int type)

4674

int flags, int type)

4644

{

4675

{

4645

if (strcmp(key, "") != 0)

4676

if (strcmp(key, "") != 0)

4646

return -EINVAL;

4677

return -EINVAL;

4647

4678

4648

return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);

4679

return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);

4649

}

4680

}

4650

4681

4651

static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,

4682

static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,

4652

void *buf, size_t buflen, int type)

4683

void *buf, size_t buflen, int type)

4653

{

4684

{

4654

if (strcmp(key, "") != 0)

4685

if (strcmp(key, "") != 0)

4655

return -EINVAL;

4686

return -EINVAL;

4656

4687

4657

return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);

4688

return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);

4658

}

4689

}

4659

4690

4660

static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,

4691

static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,

4661

size_t list_len, const char *name,

4692

size_t list_len, const char *name,

4662

size_t name_len, int type)

4693

size_t name_len, int type)

4663

{

4694

{

4664

size_t len = sizeof(XATTR_NAME_NFSV4_ACL);

4695

size_t len = sizeof(XATTR_NAME_NFSV4_ACL);

4665

4696

4666

if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))

4697

if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))

4667

return 0;

4698

return 0;

4668

4699

4669

if (list && len <= list_len)

4700

if (list && len <= list_len)

4670

memcpy(list, XATTR_NAME_NFSV4_ACL, len);

4701

memcpy(list, XATTR_NAME_NFSV4_ACL, len);

4671

return len;

4702

return len;

4672

}

4703

}

4673

4704

4674

/*

4705

/*

4675

* nfs_fhget will use either the mounted_on_fileid or the fileid

4706

* nfs_fhget will use either the mounted_on_fileid or the fileid

4676

*/

4707

*/

4677

static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)

4708

static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)

4678

{

4709

{

4679

if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||

4710

if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||

4680

(fattr->valid & NFS_ATTR_FATTR_FILEID)) &&

4711

(fattr->valid & NFS_ATTR_FATTR_FILEID)) &&

4681

(fattr->valid & NFS_ATTR_FATTR_FSID) &&

4712

(fattr->valid & NFS_ATTR_FATTR_FSID) &&

4682

(fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)))

4713

(fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)))

4683

return;

4714

return;

4684

4715

4685

fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |

4716

fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |

4686

NFS_ATTR_FATTR_NLINK;

4717

NFS_ATTR_FATTR_NLINK;

4687

fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;

4718

fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;

4688

fattr->nlink = 2;

4719

fattr->nlink = 2;

4689

}

4720

}

4690

4721

4691

int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,

4722

int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,

4692

struct nfs4_fs_locations *fs_locations, struct page *page)

4723

struct nfs4_fs_locations *fs_locations, struct page *page)

4693

{

4724

{

4694

struct nfs_server *server = NFS_SERVER(dir);

4725

struct nfs_server *server = NFS_SERVER(dir);

4695

u32 bitmask[2] = {

4726

u32 bitmask[2] = {

4696

[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,

4727

[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,

4697

};

4728

};

4698

struct nfs4_fs_locations_arg args = {

4729

struct nfs4_fs_locations_arg args = {

4699

.dir_fh = NFS_FH(dir),

4730

.dir_fh = NFS_FH(dir),

4700

.name = name,

4731

.name = name,

4701

.page = page,

4732

.page = page,

4702

.bitmask = bitmask,

4733

.bitmask = bitmask,

4703

};

4734

};

4704

struct nfs4_fs_locations_res res = {

4735

struct nfs4_fs_locations_res res = {

4705

.fs_locations = fs_locations,

4736

.fs_locations = fs_locations,

4706

};

4737

};

4707

struct rpc_message msg = {

4738

struct rpc_message msg = {

4708

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],

4739

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],

4709

.rpc_argp = &args,

4740

.rpc_argp = &args,

4710

.rpc_resp = &res,

4741

.rpc_resp = &res,

4711

};

4742

};

4712

int status;

4743

int status;

4713

4744

4714

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

4745

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

4715

4746

4716

/* Ask for the fileid of the absent filesystem if mounted_on_fileid

4747

/* Ask for the fileid of the absent filesystem if mounted_on_fileid

4717

* is not supported */

4748

* is not supported */

4718

if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)

4749

if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)

4719

bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;

4750

bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;

4720

else

4751

else

4721

bitmask[0] |= FATTR4_WORD0_FILEID;

4752

bitmask[0] |= FATTR4_WORD0_FILEID;

4722

4753

4723

nfs_fattr_init(&fs_locations->fattr);

4754

nfs_fattr_init(&fs_locations->fattr);

4724

fs_locations->server = server;

4755

fs_locations->server = server;

4725

fs_locations->nlocations = 0;

4756

fs_locations->nlocations = 0;

4726

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

4757

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

4727

dprintk("%s: returned status = %d\n", __func__, status);

4758

dprintk("%s: returned status = %d\n", __func__, status);

4728

return status;

4759

return status;

4729

}

4760

}

4730

4761

4731

static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)

4762

static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)

4732

{

4763

{

4733

int status;

4764

int status;

4734

struct nfs4_secinfo_arg args = {

4765

struct nfs4_secinfo_arg args = {

4735

.dir_fh = NFS_FH(dir),

4766

.dir_fh = NFS_FH(dir),

4736

.name = name,

4767

.name = name,

4737

};

4768

};

4738

struct nfs4_secinfo_res res = {

4769

struct nfs4_secinfo_res res = {

4739

.flavors = flavors,

4770

.flavors = flavors,

4740

};

4771

};

4741

struct rpc_message msg = {

4772

struct rpc_message msg = {

4742

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],

4773

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],

4743

.rpc_argp = &args,

4774

.rpc_argp = &args,

4744

.rpc_resp = &res,

4775

.rpc_resp = &res,

4745

};

4776

};

4746

4777

4747

dprintk("NFS call secinfo %s\n", name->name);

4778

dprintk("NFS call secinfo %s\n", name->name);

4748

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

4779

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

4749

dprintk("NFS reply secinfo: %d\n", status);

4780

dprintk("NFS reply secinfo: %d\n", status);

4750

return status;

4781

return status;

4751

}

4782

}

4752

4783

4753

int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)

4784

int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)

4754

{

4785

{

4755

struct nfs4_exception exception = { };

4786

struct nfs4_exception exception = { };

4756

int err;

4787

int err;

4757

do {

4788

do {

4758

err = nfs4_handle_exception(NFS_SERVER(dir),

4789

err = nfs4_handle_exception(NFS_SERVER(dir),

4759

_nfs4_proc_secinfo(dir, name, flavors),

4790

_nfs4_proc_secinfo(dir, name, flavors),

4760

&exception);

4791

&exception);

4761

} while (exception.retry);

4792

} while (exception.retry);

4762

return err;

4793

return err;

4763

}

4794

}

4764

4795

4765

#ifdef CONFIG_NFS_V4_1

4796

#ifdef CONFIG_NFS_V4_1

4766

/*

4797

/*

4767

* Check the exchange flags returned by the server for invalid flags, having

4798

* Check the exchange flags returned by the server for invalid flags, having

4768

* both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or

4799

* both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or

4769

* DS flags set.

4800

* DS flags set.

4770

*/

4801

*/

4771

static int nfs4_check_cl_exchange_flags(u32 flags)

4802

static int nfs4_check_cl_exchange_flags(u32 flags)

4772

{

4803

{

4773

if (flags & ~EXCHGID4_FLAG_MASK_R)

4804

if (flags & ~EXCHGID4_FLAG_MASK_R)

4774

goto out_inval;

4805

goto out_inval;

4775

if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&

4806

if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&

4776

(flags & EXCHGID4_FLAG_USE_NON_PNFS))

4807

(flags & EXCHGID4_FLAG_USE_NON_PNFS))

4777

goto out_inval;

4808

goto out_inval;

4778

if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))

4809

if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))

4779

goto out_inval;

4810

goto out_inval;

4780

return NFS_OK;

4811

return NFS_OK;

4781

out_inval:

4812

out_inval:

4782

return -NFS4ERR_INVAL;

4813

return -NFS4ERR_INVAL;

4783

}

4814

}

4784

4815

4785

static bool

4816

static bool

4786

nfs41_same_server_scope(struct server_scope *a, struct server_scope *b)

4817

nfs41_same_server_scope(struct server_scope *a, struct server_scope *b)

4787

{

4818

{

4788

if (a->server_scope_sz == b->server_scope_sz &&

4819

if (a->server_scope_sz == b->server_scope_sz &&

4789

memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)

4820

memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)

4790

return true;

4821

return true;

4791

4822

4792

return false;

4823

return false;

4793

}

4824

}

4794

4825

4795

/*

4826

/*

4796

* nfs4_proc_exchange_id()

4827

* nfs4_proc_exchange_id()

4797

*

4828

*

4798

* Since the clientid has expired, all compounds using sessions

4829

* Since the clientid has expired, all compounds using sessions

4799

* associated with the stale clientid will be returning

4830

* associated with the stale clientid will be returning

4800

* NFS4ERR_BADSESSION in the sequence operation, and will therefore

4831

* NFS4ERR_BADSESSION in the sequence operation, and will therefore

4801

* be in some phase of session reset.

4832

* be in some phase of session reset.

4802

*/

4833

*/

4803

int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)

4834

int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)

4804

{

4835

{

4805

nfs4_verifier verifier;

4836

nfs4_verifier verifier;

4806

struct nfs41_exchange_id_args args = {

4837

struct nfs41_exchange_id_args args = {

4807

.client = clp,

4838

.client = clp,

4808

.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,

4839

.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,

4809

};

4840

};

4810

struct nfs41_exchange_id_res res = {

4841

struct nfs41_exchange_id_res res = {

4811

.client = clp,

4842

.client = clp,

4812

};

4843

};

4813

int status;

4844

int status;

4814

struct rpc_message msg = {

4845

struct rpc_message msg = {

4815

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],

4846

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],

4816

.rpc_argp = &args,

4847

.rpc_argp = &args,

4817

.rpc_resp = &res,

4848

.rpc_resp = &res,

4818

.rpc_cred = cred,

4849

.rpc_cred = cred,

4819

};

4850

};

4820

__be32 *p;

4851

__be32 *p;

4821

4852

4822

dprintk("--> %s\n", __func__);

4853

dprintk("--> %s\n", __func__);

4823

BUG_ON(clp == NULL);

4854

BUG_ON(clp == NULL);

4824

4855

4825

p = (u32 *)verifier.data;

4856

p = (u32 *)verifier.data;

4826

*p++ = htonl((u32)clp->cl_boot_time.tv_sec);

4857

*p++ = htonl((u32)clp->cl_boot_time.tv_sec);

4827

*p = htonl((u32)clp->cl_boot_time.tv_nsec);

4858

*p = htonl((u32)clp->cl_boot_time.tv_nsec);

4828

args.verifier = &verifier;

4859

args.verifier = &verifier;

4829

4860

4830

args.id_len = scnprintf(args.id, sizeof(args.id),

4861

args.id_len = scnprintf(args.id, sizeof(args.id),

4831

"%s/%s.%s/%u",

4862

"%s/%s.%s/%u",

4832

clp->cl_ipaddr,

4863

clp->cl_ipaddr,

4833

init_utsname()->nodename,

4864

init_utsname()->nodename,

4834

init_utsname()->domainname,

4865

init_utsname()->domainname,

4835

clp->cl_rpcclient->cl_auth->au_flavor);

4866

clp->cl_rpcclient->cl_auth->au_flavor);

4836

4867

4837

res.server_scope = kzalloc(sizeof(struct server_scope), GFP_KERNEL);

4868

res.server_scope = kzalloc(sizeof(struct server_scope), GFP_KERNEL);

4838

if (unlikely(!res.server_scope))

4869

if (unlikely(!res.server_scope))

4839

return -ENOMEM;

4870

return -ENOMEM;

4840

4871

4841

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

4872

status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

4842

if (!status)

4873

if (!status)

4843

status = nfs4_check_cl_exchange_flags(clp->cl_exchange_flags);

4874

status = nfs4_check_cl_exchange_flags(clp->cl_exchange_flags);

4844

4875

4845

if (!status) {

4876

if (!status) {

4846

if (clp->server_scope &&

4877

if (clp->server_scope &&

4847

!nfs41_same_server_scope(clp->server_scope,

4878

!nfs41_same_server_scope(clp->server_scope,

4848

res.server_scope)) {

4879

res.server_scope)) {

4849

dprintk("%s: server_scope mismatch detected\n",

4880

dprintk("%s: server_scope mismatch detected\n",

4850

__func__);

4881

__func__);

4851

set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);

4882

set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);

4852

kfree(clp->server_scope);

4883

kfree(clp->server_scope);

4853

clp->server_scope = NULL;

4884

clp->server_scope = NULL;

4854

}

4885

}

4855

4886

4856

if (!clp->server_scope)

4887

if (!clp->server_scope)

4857

clp->server_scope = res.server_scope;

4888

clp->server_scope = res.server_scope;

4858

else

4889

else

4859

kfree(res.server_scope);

4890

kfree(res.server_scope);

4860

}

4891

}

4861

4892

4862

dprintk("<-- %s status= %d\n", __func__, status);

4893

dprintk("<-- %s status= %d\n", __func__, status);

4863

return status;

4894

return status;

4864

}

4895

}

4865

4896

4866

struct nfs4_get_lease_time_data {

4897

struct nfs4_get_lease_time_data {

4867

struct nfs4_get_lease_time_args *args;

4898

struct nfs4_get_lease_time_args *args;

4868

struct nfs4_get_lease_time_res *res;

4899

struct nfs4_get_lease_time_res *res;

4869

struct nfs_client *clp;

4900

struct nfs_client *clp;

4870

};

4901

};

4871

4902

4872

static void nfs4_get_lease_time_prepare(struct rpc_task *task,

4903

static void nfs4_get_lease_time_prepare(struct rpc_task *task,

4873

void *calldata)

4904

void *calldata)

4874

{

4905

{

4875

int ret;

4906

int ret;

4876

struct nfs4_get_lease_time_data *data =

4907

struct nfs4_get_lease_time_data *data =

4877

(struct nfs4_get_lease_time_data *)calldata;

4908

(struct nfs4_get_lease_time_data *)calldata;

4878

4909

4879

dprintk("--> %s\n", __func__);

4910

dprintk("--> %s\n", __func__);

4880

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

4911

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

4881

/* just setup sequence, do not trigger session recovery

4912

/* just setup sequence, do not trigger session recovery

4882

since we're invoked within one */

4913

since we're invoked within one */

4883

ret = nfs41_setup_sequence(data->clp->cl_session,

4914

ret = nfs41_setup_sequence(data->clp->cl_session,

4884

&data->args->la_seq_args,

4915

&data->args->la_seq_args,

4885

&data->res->lr_seq_res, 0, task);

4916

&data->res->lr_seq_res, 0, task);

4886

4917

4887

BUG_ON(ret == -EAGAIN);

4918

BUG_ON(ret == -EAGAIN);

4888

rpc_call_start(task);

4919

rpc_call_start(task);

4889

dprintk("<-- %s\n", __func__);

4920

dprintk("<-- %s\n", __func__);

4890

}

4921

}

4891

4922

4892

/*

4923

/*

4893

* Called from nfs4_state_manager thread for session setup, so don't recover

4924

* Called from nfs4_state_manager thread for session setup, so don't recover

4894

* from sequence operation or clientid errors.

4925

* from sequence operation or clientid errors.

4895

*/

4926

*/

4896

static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)

4927

static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)

4897

{

4928

{

4898

struct nfs4_get_lease_time_data *data =

4929

struct nfs4_get_lease_time_data *data =

4899

(struct nfs4_get_lease_time_data *)calldata;

4930

(struct nfs4_get_lease_time_data *)calldata;

4900

4931

4901

dprintk("--> %s\n", __func__);

4932

dprintk("--> %s\n", __func__);

4902

if (!nfs41_sequence_done(task, &data->res->lr_seq_res))

4933

if (!nfs41_sequence_done(task, &data->res->lr_seq_res))

4903

return;

4934

return;

4904

switch (task->tk_status) {

4935

switch (task->tk_status) {

4905

case -NFS4ERR_DELAY:

4936

case -NFS4ERR_DELAY:

4906

case -NFS4ERR_GRACE:

4937

case -NFS4ERR_GRACE:

4907

dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);

4938

dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);

4908

rpc_delay(task, NFS4_POLL_RETRY_MIN);

4939

rpc_delay(task, NFS4_POLL_RETRY_MIN);

4909

task->tk_status = 0;

4940

task->tk_status = 0;

4910

/* fall through */

4941

/* fall through */

4911

case -NFS4ERR_RETRY_UNCACHED_REP:

4942

case -NFS4ERR_RETRY_UNCACHED_REP:

4912

nfs_restart_rpc(task, data->clp);

4943

nfs_restart_rpc(task, data->clp);

4913

return;

4944

return;

4914

}

4945

}

4915

dprintk("<-- %s\n", __func__);

4946

dprintk("<-- %s\n", __func__);

4916

}

4947

}

4917

4948

4918

struct rpc_call_ops nfs4_get_lease_time_ops = {

4949

struct rpc_call_ops nfs4_get_lease_time_ops = {

4919

.rpc_call_prepare = nfs4_get_lease_time_prepare,

4950

.rpc_call_prepare = nfs4_get_lease_time_prepare,

4920

.rpc_call_done = nfs4_get_lease_time_done,

4951

.rpc_call_done = nfs4_get_lease_time_done,

4921

};

4952

};

4922

4953

4923

int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)

4954

int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)

4924

{

4955

{

4925

struct rpc_task *task;

4956

struct rpc_task *task;

4926

struct nfs4_get_lease_time_args args;

4957

struct nfs4_get_lease_time_args args;

4927

struct nfs4_get_lease_time_res res = {

4958

struct nfs4_get_lease_time_res res = {

4928

.lr_fsinfo = fsinfo,

4959

.lr_fsinfo = fsinfo,

4929

};

4960

};

4930

struct nfs4_get_lease_time_data data = {

4961

struct nfs4_get_lease_time_data data = {

4931

.args = &args,

4962

.args = &args,

4932

.res = &res,

4963

.res = &res,

4933

.clp = clp,

4964

.clp = clp,

4934

};

4965

};

4935

struct rpc_message msg = {

4966

struct rpc_message msg = {

4936

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],

4967

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],

4937

.rpc_argp = &args,

4968

.rpc_argp = &args,

4938

.rpc_resp = &res,

4969

.rpc_resp = &res,

4939

};

4970

};

4940

struct rpc_task_setup task_setup = {

4971

struct rpc_task_setup task_setup = {

4941

.rpc_client = clp->cl_rpcclient,

4972

.rpc_client = clp->cl_rpcclient,

4942

.rpc_message = &msg,

4973

.rpc_message = &msg,

4943

.callback_ops = &nfs4_get_lease_time_ops,

4974

.callback_ops = &nfs4_get_lease_time_ops,

4944

.callback_data = &data,

4975

.callback_data = &data,

4945

.flags = RPC_TASK_TIMEOUT,

4976

.flags = RPC_TASK_TIMEOUT,

4946

};

4977

};

4947

int status;

4978

int status;

4948

4979

4949

dprintk("--> %s\n", __func__);

4980

dprintk("--> %s\n", __func__);

4950

task = rpc_run_task(&task_setup);

4981

task = rpc_run_task(&task_setup);

4951

4982

4952

if (IS_ERR(task))

4983

if (IS_ERR(task))

4953

status = PTR_ERR(task);

4984

status = PTR_ERR(task);

4954

else {

4985

else {

4955

status = task->tk_status;

4986

status = task->tk_status;

4956

rpc_put_task(task);

4987

rpc_put_task(task);

4957

}

4988

}

4958

dprintk("<-- %s return %d\n", __func__, status);

4989

dprintk("<-- %s return %d\n", __func__, status);

4959

4990

4960

return status;

4991

return status;

4961

}

4992

}

4962

4993

4963

/*

4994

/*

4964

* Reset a slot table

4995

* Reset a slot table

4965

*/

4996

*/

4966

static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs,

4997

static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs,

4967

int ivalue)

4998

int ivalue)

4968

{

4999

{

4969

struct nfs4_slot *new = NULL;

5000

struct nfs4_slot *new = NULL;

4970

int i;

5001

int i;

4971

int ret = 0;

5002

int ret = 0;

4972

5003

4973

dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,

5004

dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,

4974

max_reqs, tbl->max_slots);

5005

max_reqs, tbl->max_slots);

4975

5006

4976

/* Does the newly negotiated max_reqs match the existing slot table? */

5007

/* Does the newly negotiated max_reqs match the existing slot table? */

4977

if (max_reqs != tbl->max_slots) {

5008

if (max_reqs != tbl->max_slots) {

4978

ret = -ENOMEM;

5009

ret = -ENOMEM;

4979

new = kmalloc(max_reqs * sizeof(struct nfs4_slot),

5010

new = kmalloc(max_reqs * sizeof(struct nfs4_slot),

4980

GFP_NOFS);

5011

GFP_NOFS);

4981

if (!new)

5012

if (!new)

4982

goto out;

5013

goto out;

4983

ret = 0;

5014

ret = 0;

4984

kfree(tbl->slots);

5015

kfree(tbl->slots);

4985

}

5016

}

4986

spin_lock(&tbl->slot_tbl_lock);

5017

spin_lock(&tbl->slot_tbl_lock);

4987

if (new) {

5018

if (new) {

4988

tbl->slots = new;

5019

tbl->slots = new;

4989

tbl->max_slots = max_reqs;

5020

tbl->max_slots = max_reqs;

4990

}

5021

}

4991

for (i = 0; i < tbl->max_slots; ++i)

5022

for (i = 0; i < tbl->max_slots; ++i)

4992

tbl->slots[i].seq_nr = ivalue;

5023

tbl->slots[i].seq_nr = ivalue;

4993

spin_unlock(&tbl->slot_tbl_lock);

5024

spin_unlock(&tbl->slot_tbl_lock);

4994

dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,

5025

dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,

4995

tbl, tbl->slots, tbl->max_slots);

5026

tbl, tbl->slots, tbl->max_slots);

4996

out:

5027

out:

4997

dprintk("<-- %s: return %d\n", __func__, ret);

5028

dprintk("<-- %s: return %d\n", __func__, ret);

4998

return ret;

5029

return ret;

4999

}

5030

}

5000

5031

5001

/*

5032

/*

5002

* Reset the forechannel and backchannel slot tables

5033

* Reset the forechannel and backchannel slot tables

5003

*/

5034

*/

5004

static int nfs4_reset_slot_tables(struct nfs4_session *session)

5035

static int nfs4_reset_slot_tables(struct nfs4_session *session)

5005

{

5036

{

5006

int status;

5037

int status;

5007

5038

5008

status = nfs4_reset_slot_table(&session->fc_slot_table,

5039

status = nfs4_reset_slot_table(&session->fc_slot_table,

5009

session->fc_attrs.max_reqs, 1);

5040

session->fc_attrs.max_reqs, 1);

5010

if (status)

5041

if (status)

5011

return status;

5042

return status;

5012

5043

5013

status = nfs4_reset_slot_table(&session->bc_slot_table,

5044

status = nfs4_reset_slot_table(&session->bc_slot_table,

5014

session->bc_attrs.max_reqs, 0);

5045

session->bc_attrs.max_reqs, 0);

5015

return status;

5046

return status;

5016

}

5047

}

5017

5048

5018

/* Destroy the slot table */

5049

/* Destroy the slot table */

5019

static void nfs4_destroy_slot_tables(struct nfs4_session *session)

5050

static void nfs4_destroy_slot_tables(struct nfs4_session *session)

5020

{

5051

{

5021

if (session->fc_slot_table.slots != NULL) {

5052

if (session->fc_slot_table.slots != NULL) {

5022

kfree(session->fc_slot_table.slots);

5053

kfree(session->fc_slot_table.slots);

5023

session->fc_slot_table.slots = NULL;

5054

session->fc_slot_table.slots = NULL;

5024

}

5055

}

5025

if (session->bc_slot_table.slots != NULL) {

5056

if (session->bc_slot_table.slots != NULL) {

5026

kfree(session->bc_slot_table.slots);

5057

kfree(session->bc_slot_table.slots);

5027

session->bc_slot_table.slots = NULL;

5058

session->bc_slot_table.slots = NULL;

5028

}

5059

}

5029

return;

5060

return;

5030

}

5061

}

5031

5062

5032

/*

5063

/*

5033

* Initialize slot table

5064

* Initialize slot table

5034

*/

5065

*/

5035

static int nfs4_init_slot_table(struct nfs4_slot_table *tbl,

5066

static int nfs4_init_slot_table(struct nfs4_slot_table *tbl,

5036

int max_slots, int ivalue)

5067

int max_slots, int ivalue)

5037

{

5068

{

5038

struct nfs4_slot *slot;

5069

struct nfs4_slot *slot;

5039

int ret = -ENOMEM;

5070

int ret = -ENOMEM;

5040

5071

5041

BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE);

5072

BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE);

5042

5073

5043

dprintk("--> %s: max_reqs=%u\n", __func__, max_slots);

5074

dprintk("--> %s: max_reqs=%u\n", __func__, max_slots);

5044

5075

5045

slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS);

5076

slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS);

5046

if (!slot)

5077

if (!slot)

5047

goto out;

5078

goto out;

5048

ret = 0;

5079

ret = 0;

5049

5080

5050

spin_lock(&tbl->slot_tbl_lock);

5081

spin_lock(&tbl->slot_tbl_lock);

5051

tbl->max_slots = max_slots;

5082

tbl->max_slots = max_slots;

5052

tbl->slots = slot;

5083

tbl->slots = slot;

5053

tbl->highest_used_slotid = -1; /* no slot is currently used */

5084

tbl->highest_used_slotid = -1; /* no slot is currently used */

5054

spin_unlock(&tbl->slot_tbl_lock);

5085

spin_unlock(&tbl->slot_tbl_lock);

5055

dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,

5086

dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,

5056

tbl, tbl->slots, tbl->max_slots);

5087

tbl, tbl->slots, tbl->max_slots);

5057

out:

5088

out:

5058

dprintk("<-- %s: return %d\n", __func__, ret);

5089

dprintk("<-- %s: return %d\n", __func__, ret);

5059

return ret;

5090

return ret;

5060

}

5091

}

5061

5092

5062

/*

5093

/*

5063

* Initialize the forechannel and backchannel tables

5094

* Initialize the forechannel and backchannel tables

5064

*/

5095

*/

5065

static int nfs4_init_slot_tables(struct nfs4_session *session)

5096

static int nfs4_init_slot_tables(struct nfs4_session *session)

5066

{

5097

{

5067

struct nfs4_slot_table *tbl;

5098

struct nfs4_slot_table *tbl;

5068

int status = 0;

5099

int status = 0;

5069

5100

5070

tbl = &session->fc_slot_table;

5101

tbl = &session->fc_slot_table;

5071

if (tbl->slots == NULL) {

5102

if (tbl->slots == NULL) {

5072

status = nfs4_init_slot_table(tbl,

5103

status = nfs4_init_slot_table(tbl,

5073

session->fc_attrs.max_reqs, 1);

5104

session->fc_attrs.max_reqs, 1);

5074

if (status)

5105

if (status)

5075

return status;

5106

return status;

5076

}

5107

}

5077

5108

5078

tbl = &session->bc_slot_table;

5109

tbl = &session->bc_slot_table;

5079

if (tbl->slots == NULL) {

5110

if (tbl->slots == NULL) {

5080

status = nfs4_init_slot_table(tbl,

5111

status = nfs4_init_slot_table(tbl,

5081

session->bc_attrs.max_reqs, 0);

5112

session->bc_attrs.max_reqs, 0);

5082

if (status)

5113

if (status)

5083

nfs4_destroy_slot_tables(session);

5114

nfs4_destroy_slot_tables(session);

5084

}

5115

}

5085

5116

5086

return status;

5117

return status;

5087

}

5118

}

5088

5119

5089

struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp)

5120

struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp)

5090

{

5121

{

5091

struct nfs4_session *session;

5122

struct nfs4_session *session;

5092

struct nfs4_slot_table *tbl;

5123

struct nfs4_slot_table *tbl;

5093

5124

5094

session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);

5125

session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);

5095

if (!session)

5126

if (!session)

5096

return NULL;

5127

return NULL;

5097

5128

5098

tbl = &session->fc_slot_table;

5129

tbl = &session->fc_slot_table;

5099

tbl->highest_used_slotid = -1;

5130

tbl->highest_used_slotid = -1;

5100

spin_lock_init(&tbl->slot_tbl_lock);

5131

spin_lock_init(&tbl->slot_tbl_lock);

5101

rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table");

5132

rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table");

5102

init_completion(&tbl->complete);

5133

init_completion(&tbl->complete);

5103

5134

5104

tbl = &session->bc_slot_table;

5135

tbl = &session->bc_slot_table;

5105

tbl->highest_used_slotid = -1;

5136

tbl->highest_used_slotid = -1;

5106

spin_lock_init(&tbl->slot_tbl_lock);

5137

spin_lock_init(&tbl->slot_tbl_lock);

5107

rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table");

5138

rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table");

5108

init_completion(&tbl->complete);

5139

init_completion(&tbl->complete);

5109

5140

5110

session->session_state = 1<<NFS4_SESSION_INITING;

5141

session->session_state = 1<<NFS4_SESSION_INITING;

5111

5142

5112

session->clp = clp;

5143

session->clp = clp;

5113

return session;

5144

return session;

5114

}

5145

}

5115

5146

5116

void nfs4_destroy_session(struct nfs4_session *session)

5147

void nfs4_destroy_session(struct nfs4_session *session)

5117

{

5148

{

5118

nfs4_proc_destroy_session(session);

5149

nfs4_proc_destroy_session(session);

5119

dprintk("%s Destroy backchannel for xprt %p\n",

5150

dprintk("%s Destroy backchannel for xprt %p\n",

5120

__func__, session->clp->cl_rpcclient->cl_xprt);

5151

__func__, session->clp->cl_rpcclient->cl_xprt);

5121

xprt_destroy_backchannel(session->clp->cl_rpcclient->cl_xprt,

5152

xprt_destroy_backchannel(session->clp->cl_rpcclient->cl_xprt,

5122

NFS41_BC_MIN_CALLBACKS);

5153

NFS41_BC_MIN_CALLBACKS);

5123

nfs4_destroy_slot_tables(session);

5154

nfs4_destroy_slot_tables(session);

5124

kfree(session);

5155

kfree(session);

5125

}

5156

}

5126

5157

5127

/*

5158

/*

5128

* Initialize the values to be used by the client in CREATE_SESSION

5159

* Initialize the values to be used by the client in CREATE_SESSION

5129

* If nfs4_init_session set the fore channel request and response sizes,

5160

* If nfs4_init_session set the fore channel request and response sizes,

5130

* use them.

5161

* use them.

5131

*

5162

*

5132

* Set the back channel max_resp_sz_cached to zero to force the client to

5163

* Set the back channel max_resp_sz_cached to zero to force the client to

5133

* always set csa_cachethis to FALSE because the current implementation

5164

* always set csa_cachethis to FALSE because the current implementation

5134

* of the back channel DRC only supports caching the CB_SEQUENCE operation.

5165

* of the back channel DRC only supports caching the CB_SEQUENCE operation.

5135

*/

5166

*/

5136

static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)

5167

static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)

5137

{

5168

{

5138

struct nfs4_session *session = args->client->cl_session;

5169

struct nfs4_session *session = args->client->cl_session;

5139

unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz,

5170

unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz,

5140

mxresp_sz = session->fc_attrs.max_resp_sz;

5171

mxresp_sz = session->fc_attrs.max_resp_sz;

5141

5172

5142

if (mxrqst_sz == 0)

5173

if (mxrqst_sz == 0)

5143

mxrqst_sz = NFS_MAX_FILE_IO_SIZE;

5174

mxrqst_sz = NFS_MAX_FILE_IO_SIZE;

5144

if (mxresp_sz == 0)

5175

if (mxresp_sz == 0)

5145

mxresp_sz = NFS_MAX_FILE_IO_SIZE;

5176

mxresp_sz = NFS_MAX_FILE_IO_SIZE;

5146

/* Fore channel attributes */

5177

/* Fore channel attributes */

5147

args->fc_attrs.max_rqst_sz = mxrqst_sz;

5178

args->fc_attrs.max_rqst_sz = mxrqst_sz;

5148

args->fc_attrs.max_resp_sz = mxresp_sz;

5179

args->fc_attrs.max_resp_sz = mxresp_sz;

5149

args->fc_attrs.max_ops = NFS4_MAX_OPS;

5180

args->fc_attrs.max_ops = NFS4_MAX_OPS;

5150

args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs;

5181

args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs;

5151

5182

5152

dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "

5183

dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "

5153

"max_ops=%u max_reqs=%u\n",

5184

"max_ops=%u max_reqs=%u\n",

5154

__func__,

5185

__func__,

5155

args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,

5186

args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,

5156

args->fc_attrs.max_ops, args->fc_attrs.max_reqs);

5187

args->fc_attrs.max_ops, args->fc_attrs.max_reqs);

5157

5188

5158

/* Back channel attributes */

5189

/* Back channel attributes */

5159

args->bc_attrs.max_rqst_sz = PAGE_SIZE;

5190

args->bc_attrs.max_rqst_sz = PAGE_SIZE;

5160

args->bc_attrs.max_resp_sz = PAGE_SIZE;

5191

args->bc_attrs.max_resp_sz = PAGE_SIZE;

5161

args->bc_attrs.max_resp_sz_cached = 0;

5192

args->bc_attrs.max_resp_sz_cached = 0;

5162

args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;

5193

args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;

5163

args->bc_attrs.max_reqs = 1;

5194

args->bc_attrs.max_reqs = 1;

5164

5195

5165

dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "

5196

dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "

5166

"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",

5197

"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",

5167

__func__,

5198

__func__,

5168

args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,

5199

args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,

5169

args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,

5200

args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,

5170

args->bc_attrs.max_reqs);

5201

args->bc_attrs.max_reqs);

5171

}

5202

}

5172

5203

5173

static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)

5204

static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)

5174

{

5205

{

5175

struct nfs4_channel_attrs *sent = &args->fc_attrs;

5206

struct nfs4_channel_attrs *sent = &args->fc_attrs;

5176

struct nfs4_channel_attrs *rcvd = &session->fc_attrs;

5207

struct nfs4_channel_attrs *rcvd = &session->fc_attrs;

5177

5208

5178

if (rcvd->max_resp_sz > sent->max_resp_sz)

5209

if (rcvd->max_resp_sz > sent->max_resp_sz)

5179

return -EINVAL;

5210

return -EINVAL;

5180

/*

5211

/*

5181

* Our requested max_ops is the minimum we need; we're not

5212

* Our requested max_ops is the minimum we need; we're not

5182

* prepared to break up compounds into smaller pieces than that.

5213

* prepared to break up compounds into smaller pieces than that.

5183

* So, no point even trying to continue if the server won't

5214

* So, no point even trying to continue if the server won't

5184

* cooperate:

5215

* cooperate:

5185

*/

5216

*/

5186

if (rcvd->max_ops < sent->max_ops)

5217

if (rcvd->max_ops < sent->max_ops)

5187

return -EINVAL;

5218

return -EINVAL;

5188

if (rcvd->max_reqs == 0)

5219

if (rcvd->max_reqs == 0)

5189

return -EINVAL;

5220

return -EINVAL;

5190

return 0;

5221

return 0;

5191

}

5222

}

5192

5223

5193

static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)

5224

static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)

5194

{

5225

{

5195

struct nfs4_channel_attrs *sent = &args->bc_attrs;

5226

struct nfs4_channel_attrs *sent = &args->bc_attrs;

5196

struct nfs4_channel_attrs *rcvd = &session->bc_attrs;

5227

struct nfs4_channel_attrs *rcvd = &session->bc_attrs;

5197

5228

5198

if (rcvd->max_rqst_sz > sent->max_rqst_sz)

5229

if (rcvd->max_rqst_sz > sent->max_rqst_sz)

5199

return -EINVAL;

5230

return -EINVAL;

5200

if (rcvd->max_resp_sz < sent->max_resp_sz)

5231

if (rcvd->max_resp_sz < sent->max_resp_sz)

5201

return -EINVAL;

5232

return -EINVAL;

5202

if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)

5233

if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)

5203

return -EINVAL;

5234

return -EINVAL;

5204

/* These would render the backchannel useless: */

5235

/* These would render the backchannel useless: */

5205

if (rcvd->max_ops == 0)

5236

if (rcvd->max_ops == 0)

5206

return -EINVAL;

5237

return -EINVAL;

5207

if (rcvd->max_reqs == 0)

5238

if (rcvd->max_reqs == 0)

5208

return -EINVAL;

5239

return -EINVAL;

5209

return 0;

5240

return 0;

5210

}

5241

}

5211

5242

5212

static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,

5243

static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,

5213

struct nfs4_session *session)

5244

struct nfs4_session *session)

5214

{

5245

{

5215

int ret;

5246

int ret;

5216

5247

5217

ret = nfs4_verify_fore_channel_attrs(args, session);

5248

ret = nfs4_verify_fore_channel_attrs(args, session);

5218

if (ret)

5249

if (ret)

5219

return ret;

5250

return ret;

5220

return nfs4_verify_back_channel_attrs(args, session);

5251

return nfs4_verify_back_channel_attrs(args, session);

5221

}

5252

}

5222

5253

5223

static int _nfs4_proc_create_session(struct nfs_client *clp)

5254

static int _nfs4_proc_create_session(struct nfs_client *clp)

5224

{

5255

{

5225

struct nfs4_session *session = clp->cl_session;

5256

struct nfs4_session *session = clp->cl_session;

5226

struct nfs41_create_session_args args = {

5257

struct nfs41_create_session_args args = {

5227

.client = clp,

5258

.client = clp,

5228

.cb_program = NFS4_CALLBACK,

5259

.cb_program = NFS4_CALLBACK,

5229

};

5260

};

5230

struct nfs41_create_session_res res = {

5261

struct nfs41_create_session_res res = {

5231

.client = clp,

5262

.client = clp,

5232

};

5263

};

5233

struct rpc_message msg = {

5264

struct rpc_message msg = {

5234

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],

5265

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],

5235

.rpc_argp = &args,

5266

.rpc_argp = &args,

5236

.rpc_resp = &res,

5267

.rpc_resp = &res,

5237

};

5268

};

5238

int status;

5269

int status;

5239

5270

5240

nfs4_init_channel_attrs(&args);

5271

nfs4_init_channel_attrs(&args);

5241

args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);

5272

args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);

5242

5273

5243

status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

5274

status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

5244

5275

5245

if (!status)

5276

if (!status)

5246

/* Verify the session's negotiated channel_attrs values */

5277

/* Verify the session's negotiated channel_attrs values */

5247

status = nfs4_verify_channel_attrs(&args, session);

5278

status = nfs4_verify_channel_attrs(&args, session);

5248

if (!status) {

5279

if (!status) {

5249

/* Increment the clientid slot sequence id */

5280

/* Increment the clientid slot sequence id */

5250

clp->cl_seqid++;

5281

clp->cl_seqid++;

5251

}

5282

}

5252

5283

5253

return status;

5284

return status;

5254

}

5285

}

5255

5286

5256

/*

5287

/*

5257

* Issues a CREATE_SESSION operation to the server.

5288

* Issues a CREATE_SESSION operation to the server.

5258

* It is the responsibility of the caller to verify the session is

5289

* It is the responsibility of the caller to verify the session is

5259

* expired before calling this routine.

5290

* expired before calling this routine.

5260

*/

5291

*/

5261

int nfs4_proc_create_session(struct nfs_client *clp)

5292

int nfs4_proc_create_session(struct nfs_client *clp)

5262

{

5293

{

5263

int status;

5294

int status;

5264

unsigned *ptr;

5295

unsigned *ptr;

5265

struct nfs4_session *session = clp->cl_session;

5296

struct nfs4_session *session = clp->cl_session;

5266

5297

5267

dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);

5298

dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);

5268

5299

5269

status = _nfs4_proc_create_session(clp);

5300

status = _nfs4_proc_create_session(clp);

5270

if (status)

5301

if (status)

5271

goto out;

5302

goto out;

5272

5303

5273

/* Init and reset the fore channel */

5304

/* Init and reset the fore channel */

5274

status = nfs4_init_slot_tables(session);

5305

status = nfs4_init_slot_tables(session);

5275

dprintk("slot table initialization returned %d\n", status);

5306

dprintk("slot table initialization returned %d\n", status);

5276

if (status)

5307

if (status)

5277

goto out;

5308

goto out;

5278

status = nfs4_reset_slot_tables(session);

5309

status = nfs4_reset_slot_tables(session);

5279

dprintk("slot table reset returned %d\n", status);

5310

dprintk("slot table reset returned %d\n", status);

5280

if (status)

5311

if (status)

5281

goto out;

5312

goto out;

5282

5313

5283

ptr = (unsigned *)&session->sess_id.data[0];

5314

ptr = (unsigned *)&session->sess_id.data[0];

5284

dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,

5315

dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,

5285

clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);

5316

clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);

5286

out:

5317

out:

5287

dprintk("<-- %s\n", __func__);

5318

dprintk("<-- %s\n", __func__);

5288

return status;

5319

return status;

5289

}

5320

}

5290

5321

5291

/*

5322

/*

5292

* Issue the over-the-wire RPC DESTROY_SESSION.

5323

* Issue the over-the-wire RPC DESTROY_SESSION.

5293

* The caller must serialize access to this routine.

5324

* The caller must serialize access to this routine.

5294

*/

5325

*/

5295

int nfs4_proc_destroy_session(struct nfs4_session *session)

5326

int nfs4_proc_destroy_session(struct nfs4_session *session)

5296

{

5327

{

5297

int status = 0;

5328

int status = 0;

5298

struct rpc_message msg;

5329

struct rpc_message msg;

5299

5330

5300

dprintk("--> nfs4_proc_destroy_session\n");

5331

dprintk("--> nfs4_proc_destroy_session\n");

5301

5332

5302

/* session is still being setup */

5333

/* session is still being setup */

5303

if (session->clp->cl_cons_state != NFS_CS_READY)

5334

if (session->clp->cl_cons_state != NFS_CS_READY)

5304

return status;

5335

return status;

5305

5336

5306

msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION];

5337

msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION];

5307

msg.rpc_argp = session;

5338

msg.rpc_argp = session;

5308

msg.rpc_resp = NULL;

5339

msg.rpc_resp = NULL;

5309

msg.rpc_cred = NULL;

5340

msg.rpc_cred = NULL;

5310

status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

5341

status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);

5311

5342

5312

if (status)

5343

if (status)

5313

printk(KERN_WARNING

5344

printk(KERN_WARNING

5314

"Got error %d from the server on DESTROY_SESSION. "

5345

"Got error %d from the server on DESTROY_SESSION. "

5315

"Session has been destroyed regardless...\n", status);

5346

"Session has been destroyed regardless...\n", status);

5316

5347

5317

dprintk("<-- nfs4_proc_destroy_session\n");

5348

dprintk("<-- nfs4_proc_destroy_session\n");

5318

return status;

5349

return status;

5319

}

5350

}

5320

5351

5321

int nfs4_init_session(struct nfs_server *server)

5352

int nfs4_init_session(struct nfs_server *server)

5322

{

5353

{

5323

struct nfs_client *clp = server->nfs_client;

5354

struct nfs_client *clp = server->nfs_client;

5324

struct nfs4_session *session;

5355

struct nfs4_session *session;

5325

unsigned int rsize, wsize;

5356

unsigned int rsize, wsize;

5326

int ret;

5357

int ret;

5327

5358

5328

if (!nfs4_has_session(clp))

5359

if (!nfs4_has_session(clp))

5329

return 0;

5360

return 0;

5330

5361

5331

session = clp->cl_session;

5362

session = clp->cl_session;

5332

if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))

5363

if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))

5333

return 0;

5364

return 0;

5334

5365

5335

rsize = server->rsize;

5366

rsize = server->rsize;

5336

if (rsize == 0)

5367

if (rsize == 0)

5337

rsize = NFS_MAX_FILE_IO_SIZE;

5368

rsize = NFS_MAX_FILE_IO_SIZE;

5338

wsize = server->wsize;

5369

wsize = server->wsize;

5339

if (wsize == 0)

5370

if (wsize == 0)

5340

wsize = NFS_MAX_FILE_IO_SIZE;

5371

wsize = NFS_MAX_FILE_IO_SIZE;

5341

5372

5342

session->fc_attrs.max_rqst_sz = wsize + nfs41_maxwrite_overhead;

5373

session->fc_attrs.max_rqst_sz = wsize + nfs41_maxwrite_overhead;

5343

session->fc_attrs.max_resp_sz = rsize + nfs41_maxread_overhead;

5374

session->fc_attrs.max_resp_sz = rsize + nfs41_maxread_overhead;

5344

5375

5345

ret = nfs4_recover_expired_lease(server);

5376

ret = nfs4_recover_expired_lease(server);

5346

if (!ret)

5377

if (!ret)

5347

ret = nfs4_check_client_ready(clp);

5378

ret = nfs4_check_client_ready(clp);

5348

return ret;

5379

return ret;

5349

}

5380

}

5350

5381

5351

int nfs4_init_ds_session(struct nfs_client *clp)

5382

int nfs4_init_ds_session(struct nfs_client *clp)

5352

{

5383

{

5353

struct nfs4_session *session = clp->cl_session;

5384

struct nfs4_session *session = clp->cl_session;

5354

int ret;

5385

int ret;

5355

5386

5356

if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))

5387

if (!test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state))

5357

return 0;

5388

return 0;

5358

5389

5359

ret = nfs4_client_recover_expired_lease(clp);

5390

ret = nfs4_client_recover_expired_lease(clp);

5360

if (!ret)

5391

if (!ret)

5361

/* Test for the DS role */

5392

/* Test for the DS role */

5362

if (!is_ds_client(clp))

5393

if (!is_ds_client(clp))

5363

ret = -ENODEV;

5394

ret = -ENODEV;

5364

if (!ret)

5395

if (!ret)

5365

ret = nfs4_check_client_ready(clp);

5396

ret = nfs4_check_client_ready(clp);

5366

return ret;

5397

return ret;

5367

5398

5368

}

5399

}

5369

EXPORT_SYMBOL_GPL(nfs4_init_ds_session);

5400

EXPORT_SYMBOL_GPL(nfs4_init_ds_session);

5370

5401

5371

5402

5372

/*

5403

/*

5373

* Renew the cl_session lease.

5404

* Renew the cl_session lease.

5374

*/

5405

*/

5375

struct nfs4_sequence_data {

5406

struct nfs4_sequence_data {

5376

struct nfs_client *clp;

5407

struct nfs_client *clp;

5377

struct nfs4_sequence_args args;

5408

struct nfs4_sequence_args args;

5378

struct nfs4_sequence_res res;

5409

struct nfs4_sequence_res res;

5379

};

5410

};

5380

5411

5381

static void nfs41_sequence_release(void *data)

5412

static void nfs41_sequence_release(void *data)

5382

{

5413

{

5383

struct nfs4_sequence_data *calldata = data;

5414

struct nfs4_sequence_data *calldata = data;

5384

struct nfs_client *clp = calldata->clp;

5415

struct nfs_client *clp = calldata->clp;

5385

5416

5386

if (atomic_read(&clp->cl_count) > 1)

5417

if (atomic_read(&clp->cl_count) > 1)

5387

nfs4_schedule_state_renewal(clp);

5418

nfs4_schedule_state_renewal(clp);

5388

nfs_put_client(clp);

5419

nfs_put_client(clp);

5389

kfree(calldata);

5420

kfree(calldata);

5390

}

5421

}

5391

5422

5392

static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)

5423

static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)

5393

{

5424

{

5394

switch(task->tk_status) {

5425

switch(task->tk_status) {

5395

case -NFS4ERR_DELAY:

5426

case -NFS4ERR_DELAY:

5396

rpc_delay(task, NFS4_POLL_RETRY_MAX);

5427

rpc_delay(task, NFS4_POLL_RETRY_MAX);

5397

return -EAGAIN;

5428

return -EAGAIN;

5398

default:

5429

default:

5399

nfs4_schedule_lease_recovery(clp);

5430

nfs4_schedule_lease_recovery(clp);

5400

}

5431

}

5401

return 0;

5432

return 0;

5402

}

5433

}

5403

5434

5404

static void nfs41_sequence_call_done(struct rpc_task *task, void *data)

5435

static void nfs41_sequence_call_done(struct rpc_task *task, void *data)

5405

{

5436

{

5406

struct nfs4_sequence_data *calldata = data;

5437

struct nfs4_sequence_data *calldata = data;

5407

struct nfs_client *clp = calldata->clp;

5438

struct nfs_client *clp = calldata->clp;

5408

5439

5409

if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))

5440

if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))

5410

return;

5441

return;

5411

5442

5412

if (task->tk_status < 0) {

5443

if (task->tk_status < 0) {

5413

dprintk("%s ERROR %d\n", __func__, task->tk_status);

5444

dprintk("%s ERROR %d\n", __func__, task->tk_status);

5414

if (atomic_read(&clp->cl_count) == 1)

5445

if (atomic_read(&clp->cl_count) == 1)

5415

goto out;

5446

goto out;

5416

5447

5417

if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {

5448

if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {

5418

rpc_restart_call_prepare(task);

5449

rpc_restart_call_prepare(task);

5419

return;

5450

return;

5420

}

5451

}

5421

}

5452

}

5422

dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);

5453

dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);

5423

out:

5454

out:

5424

dprintk("<-- %s\n", __func__);

5455

dprintk("<-- %s\n", __func__);

5425

}

5456

}

5426

5457

5427

static void nfs41_sequence_prepare(struct rpc_task *task, void *data)

5458

static void nfs41_sequence_prepare(struct rpc_task *task, void *data)

5428

{

5459

{

5429

struct nfs4_sequence_data *calldata = data;

5460

struct nfs4_sequence_data *calldata = data;

5430

struct nfs_client *clp = calldata->clp;

5461

struct nfs_client *clp = calldata->clp;

5431

struct nfs4_sequence_args *args;

5462

struct nfs4_sequence_args *args;

5432

struct nfs4_sequence_res *res;

5463

struct nfs4_sequence_res *res;

5433

5464

5434

args = task->tk_msg.rpc_argp;

5465

args = task->tk_msg.rpc_argp;

5435

res = task->tk_msg.rpc_resp;

5466

res = task->tk_msg.rpc_resp;

5436

5467

5437

if (nfs41_setup_sequence(clp->cl_session, args, res, 0, task))

5468

if (nfs41_setup_sequence(clp->cl_session, args, res, 0, task))

5438

return;

5469

return;

5439

rpc_call_start(task);

5470

rpc_call_start(task);

5440

}

5471

}

5441

5472

5442

static const struct rpc_call_ops nfs41_sequence_ops = {

5473

static const struct rpc_call_ops nfs41_sequence_ops = {

5443

.rpc_call_done = nfs41_sequence_call_done,

5474

.rpc_call_done = nfs41_sequence_call_done,

5444

.rpc_call_prepare = nfs41_sequence_prepare,

5475

.rpc_call_prepare = nfs41_sequence_prepare,

5445

.rpc_release = nfs41_sequence_release,

5476

.rpc_release = nfs41_sequence_release,

5446

};

5477

};

5447

5478

5448

static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5479

static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5449

{

5480

{

5450

struct nfs4_sequence_data *calldata;

5481

struct nfs4_sequence_data *calldata;

5451

struct rpc_message msg = {

5482

struct rpc_message msg = {

5452

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],

5483

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],

5453

.rpc_cred = cred,

5484

.rpc_cred = cred,

5454

};

5485

};

5455

struct rpc_task_setup task_setup_data = {

5486

struct rpc_task_setup task_setup_data = {

5456

.rpc_client = clp->cl_rpcclient,

5487

.rpc_client = clp->cl_rpcclient,

5457

.rpc_message = &msg,

5488

.rpc_message = &msg,

5458

.callback_ops = &nfs41_sequence_ops,

5489

.callback_ops = &nfs41_sequence_ops,

5459

.flags = RPC_TASK_ASYNC | RPC_TASK_SOFT,

5490

.flags = RPC_TASK_ASYNC | RPC_TASK_SOFT,

5460

};

5491

};

5461

5492

5462

if (!atomic_inc_not_zero(&clp->cl_count))

5493

if (!atomic_inc_not_zero(&clp->cl_count))

5463

return ERR_PTR(-EIO);

5494

return ERR_PTR(-EIO);

5464

calldata = kzalloc(sizeof(*calldata), GFP_NOFS);

5495

calldata = kzalloc(sizeof(*calldata), GFP_NOFS);

5465

if (calldata == NULL) {

5496

if (calldata == NULL) {

5466

nfs_put_client(clp);

5497

nfs_put_client(clp);

5467

return ERR_PTR(-ENOMEM);

5498

return ERR_PTR(-ENOMEM);

5468

}

5499

}

5469

msg.rpc_argp = &calldata->args;

5500

msg.rpc_argp = &calldata->args;

5470

msg.rpc_resp = &calldata->res;

5501

msg.rpc_resp = &calldata->res;

5471

calldata->clp = clp;

5502

calldata->clp = clp;

5472

task_setup_data.callback_data = calldata;

5503

task_setup_data.callback_data = calldata;

5473

5504

5474

return rpc_run_task(&task_setup_data);

5505

return rpc_run_task(&task_setup_data);

5475

}

5506

}

5476

5507

5477

static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5508

static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5478

{

5509

{

5479

struct rpc_task *task;

5510

struct rpc_task *task;

5480

int ret = 0;

5511

int ret = 0;

5481

5512

5482

task = _nfs41_proc_sequence(clp, cred);

5513

task = _nfs41_proc_sequence(clp, cred);

5483

if (IS_ERR(task))

5514

if (IS_ERR(task))

5484

ret = PTR_ERR(task);

5515

ret = PTR_ERR(task);

5485

else

5516

else

5486

rpc_put_task_async(task);

5517

rpc_put_task_async(task);

5487

dprintk("<-- %s status=%d\n", __func__, ret);

5518

dprintk("<-- %s status=%d\n", __func__, ret);

5488

return ret;

5519

return ret;

5489

}

5520

}

5490

5521

5491

static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5522

static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)

5492

{

5523

{

5493

struct rpc_task *task;

5524

struct rpc_task *task;

5494

int ret;

5525

int ret;

5495

5526

5496

task = _nfs41_proc_sequence(clp, cred);

5527

task = _nfs41_proc_sequence(clp, cred);

5497

if (IS_ERR(task)) {

5528

if (IS_ERR(task)) {

5498

ret = PTR_ERR(task);

5529

ret = PTR_ERR(task);

5499

goto out;

5530

goto out;

5500

}

5531

}

5501

ret = rpc_wait_for_completion_task(task);

5532

ret = rpc_wait_for_completion_task(task);

5502

if (!ret) {

5533

if (!ret) {

5503

struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;

5534

struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;

5504

5535

5505

if (task->tk_status == 0)

5536

if (task->tk_status == 0)

5506

nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);

5537

nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);

5507

ret = task->tk_status;

5538

ret = task->tk_status;

5508

}

5539

}

5509

rpc_put_task(task);

5540

rpc_put_task(task);

5510

out:

5541

out:

5511

dprintk("<-- %s status=%d\n", __func__, ret);

5542

dprintk("<-- %s status=%d\n", __func__, ret);

5512

return ret;

5543

return ret;

5513

}

5544

}

5514

5545

5515

struct nfs4_reclaim_complete_data {

5546

struct nfs4_reclaim_complete_data {

5516

struct nfs_client *clp;

5547

struct nfs_client *clp;

5517

struct nfs41_reclaim_complete_args arg;

5548

struct nfs41_reclaim_complete_args arg;

5518

struct nfs41_reclaim_complete_res res;

5549

struct nfs41_reclaim_complete_res res;

5519

};

5550

};

5520

5551

5521

static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)

5552

static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)

5522

{

5553

{

5523

struct nfs4_reclaim_complete_data *calldata = data;

5554

struct nfs4_reclaim_complete_data *calldata = data;

5524

5555

5525

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

5556

rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);

5526

if (nfs41_setup_sequence(calldata->clp->cl_session,

5557

if (nfs41_setup_sequence(calldata->clp->cl_session,

5527

&calldata->arg.seq_args,

5558

&calldata->arg.seq_args,

5528

&calldata->res.seq_res, 0, task))

5559

&calldata->res.seq_res, 0, task))

5529

return;

5560

return;

5530

5561

5531

rpc_call_start(task);

5562

rpc_call_start(task);

5532

}

5563

}

5533

5564

5534

static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)

5565

static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)

5535

{

5566

{

5536

switch(task->tk_status) {

5567

switch(task->tk_status) {

5537

case 0:

5568

case 0:

5538

case -NFS4ERR_COMPLETE_ALREADY:

5569

case -NFS4ERR_COMPLETE_ALREADY:

5539

case -NFS4ERR_WRONG_CRED: /* What to do here? */

5570

case -NFS4ERR_WRONG_CRED: /* What to do here? */

5540

break;

5571

break;

5541

case -NFS4ERR_DELAY:

5572

case -NFS4ERR_DELAY:

5542

rpc_delay(task, NFS4_POLL_RETRY_MAX);

5573

rpc_delay(task, NFS4_POLL_RETRY_MAX);

5543

/* fall through */

5574

/* fall through */

5544

case -NFS4ERR_RETRY_UNCACHED_REP:

5575

case -NFS4ERR_RETRY_UNCACHED_REP:

5545

return -EAGAIN;

5576

return -EAGAIN;

5546

default:

5577

default:

5547

nfs4_schedule_lease_recovery(clp);

5578

nfs4_schedule_lease_recovery(clp);

5548

}

5579

}

5549

return 0;

5580

return 0;

5550

}

5581

}

5551

5582

5552

static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)

5583

static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)

5553

{

5584

{

5554

struct nfs4_reclaim_complete_data *calldata = data;

5585

struct nfs4_reclaim_complete_data *calldata = data;

5555

struct nfs_client *clp = calldata->clp;

5586

struct nfs_client *clp = calldata->clp;

5556

struct nfs4_sequence_res *res = &calldata->res.seq_res;

5587

struct nfs4_sequence_res *res = &calldata->res.seq_res;

5557

5588

5558

dprintk("--> %s\n", __func__);

5589

dprintk("--> %s\n", __func__);

5559

if (!nfs41_sequence_done(task, res))

5590

if (!nfs41_sequence_done(task, res))

5560

return;

5591

return;

5561

5592

5562

if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {

5593

if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {

5563

rpc_restart_call_prepare(task);

5594

rpc_restart_call_prepare(task);

5564

return;

5595

return;

5565

}

5596

}

5566

dprintk("<-- %s\n", __func__);

5597

dprintk("<-- %s\n", __func__);

5567

}

5598

}

5568

5599

5569

static void nfs4_free_reclaim_complete_data(void *data)

5600

static void nfs4_free_reclaim_complete_data(void *data)

5570

{

5601

{

5571

struct nfs4_reclaim_complete_data *calldata = data;

5602

struct nfs4_reclaim_complete_data *calldata = data;

5572

5603

5573

kfree(calldata);

5604

kfree(calldata);

5574

}

5605

}

5575

5606

5576

static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {

5607

static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {

5577

.rpc_call_prepare = nfs4_reclaim_complete_prepare,

5608

.rpc_call_prepare = nfs4_reclaim_complete_prepare,

5578

.rpc_call_done = nfs4_reclaim_complete_done,

5609

.rpc_call_done = nfs4_reclaim_complete_done,

5579

.rpc_release = nfs4_free_reclaim_complete_data,

5610

.rpc_release = nfs4_free_reclaim_complete_data,

5580

};

5611

};

5581

5612

5582

/*

5613

/*

5583

* Issue a global reclaim complete.

5614

* Issue a global reclaim complete.

5584

*/

5615

*/

5585

static int nfs41_proc_reclaim_complete(struct nfs_client *clp)

5616

static int nfs41_proc_reclaim_complete(struct nfs_client *clp)

5586

{

5617

{

5587

struct nfs4_reclaim_complete_data *calldata;

5618

struct nfs4_reclaim_complete_data *calldata;

5588

struct rpc_task *task;

5619

struct rpc_task *task;

5589

struct rpc_message msg = {

5620

struct rpc_message msg = {

5590

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],

5621

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],

5591

};

5622

};

5592

struct rpc_task_setup task_setup_data = {

5623

struct rpc_task_setup task_setup_data = {

5593

.rpc_client = clp->cl_rpcclient,

5624

.rpc_client = clp->cl_rpcclient,

5594

.rpc_message = &msg,

5625

.rpc_message = &msg,

5595

.callback_ops = &nfs4_reclaim_complete_call_ops,

5626

.callback_ops = &nfs4_reclaim_complete_call_ops,

5596

.flags = RPC_TASK_ASYNC,

5627

.flags = RPC_TASK_ASYNC,

5597

};

5628

};

5598

int status = -ENOMEM;

5629

int status = -ENOMEM;

5599

5630

5600

dprintk("--> %s\n", __func__);

5631

dprintk("--> %s\n", __func__);

5601

calldata = kzalloc(sizeof(*calldata), GFP_NOFS);

5632

calldata = kzalloc(sizeof(*calldata), GFP_NOFS);

5602

if (calldata == NULL)

5633

if (calldata == NULL)

5603

goto out;

5634

goto out;

5604

calldata->clp = clp;

5635

calldata->clp = clp;

5605

calldata->arg.one_fs = 0;

5636

calldata->arg.one_fs = 0;

5606

5637

5607

msg.rpc_argp = &calldata->arg;

5638

msg.rpc_argp = &calldata->arg;

5608

msg.rpc_resp = &calldata->res;

5639

msg.rpc_resp = &calldata->res;

5609

task_setup_data.callback_data = calldata;

5640

task_setup_data.callback_data = calldata;

5610

task = rpc_run_task(&task_setup_data);

5641

task = rpc_run_task(&task_setup_data);

5611

if (IS_ERR(task)) {

5642

if (IS_ERR(task)) {

5612

status = PTR_ERR(task);

5643

status = PTR_ERR(task);

5613

goto out;

5644

goto out;

5614

}

5645

}

5615

status = nfs4_wait_for_completion_rpc_task(task);

5646

status = nfs4_wait_for_completion_rpc_task(task);

5616

if (status == 0)

5647

if (status == 0)

5617

status = task->tk_status;

5648

status = task->tk_status;

5618

rpc_put_task(task);

5649

rpc_put_task(task);

5619

return 0;

5650

return 0;

5620

out:

5651

out:

5621

dprintk("<-- %s status=%d\n", __func__, status);

5652

dprintk("<-- %s status=%d\n", __func__, status);

5622

return status;

5653

return status;

5623

}

5654

}

5624

5655

5625

static void

5656

static void

5626

nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)

5657

nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)

5627

{

5658

{

5628

struct nfs4_layoutget *lgp = calldata;

5659

struct nfs4_layoutget *lgp = calldata;

5629

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5660

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5630

5661

5631

dprintk("--> %s\n", __func__);

5662

dprintk("--> %s\n", __func__);

5632

/* Note the is a race here, where a CB_LAYOUTRECALL can come in

5663

/* Note the is a race here, where a CB_LAYOUTRECALL can come in

5633

* right now covering the LAYOUTGET we are about to send.

5664

* right now covering the LAYOUTGET we are about to send.

5634

* However, that is not so catastrophic, and there seems

5665

* However, that is not so catastrophic, and there seems

5635

* to be no way to prevent it completely.

5666

* to be no way to prevent it completely.

5636

*/

5667

*/

5637

if (nfs4_setup_sequence(server, &lgp->args.seq_args,

5668

if (nfs4_setup_sequence(server, &lgp->args.seq_args,

5638

&lgp->res.seq_res, 0, task))

5669

&lgp->res.seq_res, 0, task))

5639

return;

5670

return;

5640

if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,

5671

if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,

5641

NFS_I(lgp->args.inode)->layout,

5672

NFS_I(lgp->args.inode)->layout,

5642

lgp->args.ctx->state)) {

5673

lgp->args.ctx->state)) {

5643

rpc_exit(task, NFS4_OK);

5674

rpc_exit(task, NFS4_OK);

5644

return;

5675

return;

5645

}

5676

}

5646

rpc_call_start(task);

5677

rpc_call_start(task);

5647

}

5678

}

5648

5679

5649

static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)

5680

static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)

5650

{

5681

{

5651

struct nfs4_layoutget *lgp = calldata;

5682

struct nfs4_layoutget *lgp = calldata;

5652

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5683

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5653

5684

5654

dprintk("--> %s\n", __func__);

5685

dprintk("--> %s\n", __func__);

5655

5686

5656

if (!nfs4_sequence_done(task, &lgp->res.seq_res))

5687

if (!nfs4_sequence_done(task, &lgp->res.seq_res))

5657

return;

5688

return;

5658

5689

5659

switch (task->tk_status) {

5690

switch (task->tk_status) {

5660

case 0:

5691

case 0:

5661

break;

5692

break;

5662

case -NFS4ERR_LAYOUTTRYLATER:

5693

case -NFS4ERR_LAYOUTTRYLATER:

5663

case -NFS4ERR_RECALLCONFLICT:

5694

case -NFS4ERR_RECALLCONFLICT:

5664

task->tk_status = -NFS4ERR_DELAY;

5695

task->tk_status = -NFS4ERR_DELAY;

5665

/* Fall through */

5696

/* Fall through */

5666

default:

5697

default:

5667

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5698

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5668

rpc_restart_call_prepare(task);

5699

rpc_restart_call_prepare(task);

5669

return;

5700

return;

5670

}

5701

}

5671

}

5702

}

5672

dprintk("<-- %s\n", __func__);

5703

dprintk("<-- %s\n", __func__);

5673

}

5704

}

5674

5705

5675

static void nfs4_layoutget_release(void *calldata)

5706

static void nfs4_layoutget_release(void *calldata)

5676

{

5707

{

5677

struct nfs4_layoutget *lgp = calldata;

5708

struct nfs4_layoutget *lgp = calldata;

5678

5709

5679

dprintk("--> %s\n", __func__);

5710

dprintk("--> %s\n", __func__);

5680

put_nfs_open_context(lgp->args.ctx);

5711

put_nfs_open_context(lgp->args.ctx);

5681

kfree(calldata);

5712

kfree(calldata);

5682

dprintk("<-- %s\n", __func__);

5713

dprintk("<-- %s\n", __func__);

5683

}

5714

}

5684

5715

5685

static const struct rpc_call_ops nfs4_layoutget_call_ops = {

5716

static const struct rpc_call_ops nfs4_layoutget_call_ops = {

5686

.rpc_call_prepare = nfs4_layoutget_prepare,

5717

.rpc_call_prepare = nfs4_layoutget_prepare,

5687

.rpc_call_done = nfs4_layoutget_done,

5718

.rpc_call_done = nfs4_layoutget_done,

5688

.rpc_release = nfs4_layoutget_release,

5719

.rpc_release = nfs4_layoutget_release,

5689

};

5720

};

5690

5721

5691

int nfs4_proc_layoutget(struct nfs4_layoutget *lgp)

5722

int nfs4_proc_layoutget(struct nfs4_layoutget *lgp)

5692

{

5723

{

5693

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5724

struct nfs_server *server = NFS_SERVER(lgp->args.inode);

5694

struct rpc_task *task;

5725

struct rpc_task *task;

5695

struct rpc_message msg = {

5726

struct rpc_message msg = {

5696

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],

5727

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],

5697

.rpc_argp = &lgp->args,

5728

.rpc_argp = &lgp->args,

5698

.rpc_resp = &lgp->res,

5729

.rpc_resp = &lgp->res,

5699

};

5730

};

5700

struct rpc_task_setup task_setup_data = {

5731

struct rpc_task_setup task_setup_data = {

5701

.rpc_client = server->client,

5732

.rpc_client = server->client,

5702

.rpc_message = &msg,

5733

.rpc_message = &msg,

5703

.callback_ops = &nfs4_layoutget_call_ops,

5734

.callback_ops = &nfs4_layoutget_call_ops,

5704

.callback_data = lgp,

5735

.callback_data = lgp,

5705

.flags = RPC_TASK_ASYNC,

5736

.flags = RPC_TASK_ASYNC,

5706

};

5737

};

5707

int status = 0;

5738

int status = 0;

5708

5739

5709

dprintk("--> %s\n", __func__);

5740

dprintk("--> %s\n", __func__);

5710

5741

5711

lgp->res.layoutp = &lgp->args.layout;

5742

lgp->res.layoutp = &lgp->args.layout;

5712

lgp->res.seq_res.sr_slot = NULL;

5743

lgp->res.seq_res.sr_slot = NULL;

5713

task = rpc_run_task(&task_setup_data);

5744

task = rpc_run_task(&task_setup_data);

5714

if (IS_ERR(task))

5745

if (IS_ERR(task))

5715

return PTR_ERR(task);

5746

return PTR_ERR(task);

5716

status = nfs4_wait_for_completion_rpc_task(task);

5747

status = nfs4_wait_for_completion_rpc_task(task);

5717

if (status == 0)

5748

if (status == 0)

5718

status = task->tk_status;

5749

status = task->tk_status;

5719

if (status == 0)

5750

if (status == 0)

5720

status = pnfs_layout_process(lgp);

5751

status = pnfs_layout_process(lgp);

5721

rpc_put_task(task);

5752

rpc_put_task(task);

5722

dprintk("<-- %s status=%d\n", __func__, status);

5753

dprintk("<-- %s status=%d\n", __func__, status);

5723

return status;

5754

return status;

5724

}

5755

}

5725

5756

5726

static void

5757

static void

5727

nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)

5758

nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)

5728

{

5759

{

5729

struct nfs4_layoutreturn *lrp = calldata;

5760

struct nfs4_layoutreturn *lrp = calldata;

5730

5761

5731

dprintk("--> %s\n", __func__);

5762

dprintk("--> %s\n", __func__);

5732

if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args,

5763

if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args,

5733

&lrp->res.seq_res, 0, task))

5764

&lrp->res.seq_res, 0, task))

5734

return;

5765

return;

5735

rpc_call_start(task);

5766

rpc_call_start(task);

5736

}

5767

}

5737

5768

5738

static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)

5769

static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)

5739

{

5770

{

5740

struct nfs4_layoutreturn *lrp = calldata;

5771

struct nfs4_layoutreturn *lrp = calldata;

5741

struct nfs_server *server;

5772

struct nfs_server *server;

5742

struct pnfs_layout_hdr *lo = NFS_I(lrp->args.inode)->layout;

5773

struct pnfs_layout_hdr *lo = NFS_I(lrp->args.inode)->layout;

5743

5774

5744

dprintk("--> %s\n", __func__);

5775

dprintk("--> %s\n", __func__);

5745

5776

5746

if (!nfs4_sequence_done(task, &lrp->res.seq_res))

5777

if (!nfs4_sequence_done(task, &lrp->res.seq_res))

5747

return;

5778

return;

5748

5779

5749

server = NFS_SERVER(lrp->args.inode);

5780

server = NFS_SERVER(lrp->args.inode);

5750

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5781

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5751

nfs_restart_rpc(task, lrp->clp);

5782

nfs_restart_rpc(task, lrp->clp);

5752

return;

5783

return;

5753

}

5784

}

5754

spin_lock(&lo->plh_inode->i_lock);

5785

spin_lock(&lo->plh_inode->i_lock);

5755

if (task->tk_status == 0) {

5786

if (task->tk_status == 0) {

5756

if (lrp->res.lrs_present) {

5787

if (lrp->res.lrs_present) {

5757

pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);

5788

pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);

5758

} else

5789

} else

5759

BUG_ON(!list_empty(&lo->plh_segs));

5790

BUG_ON(!list_empty(&lo->plh_segs));

5760

}

5791

}

5761

lo->plh_block_lgets--;

5792

lo->plh_block_lgets--;

5762

spin_unlock(&lo->plh_inode->i_lock);

5793

spin_unlock(&lo->plh_inode->i_lock);

5763

dprintk("<-- %s\n", __func__);

5794

dprintk("<-- %s\n", __func__);

5764

}

5795

}

5765

5796

5766

static void nfs4_layoutreturn_release(void *calldata)

5797

static void nfs4_layoutreturn_release(void *calldata)

5767

{

5798

{

5768

struct nfs4_layoutreturn *lrp = calldata;

5799

struct nfs4_layoutreturn *lrp = calldata;

5769

5800

5770

dprintk("--> %s\n", __func__);

5801

dprintk("--> %s\n", __func__);

5771

put_layout_hdr(NFS_I(lrp->args.inode)->layout);

5802

put_layout_hdr(NFS_I(lrp->args.inode)->layout);

5772

kfree(calldata);

5803

kfree(calldata);

5773

dprintk("<-- %s\n", __func__);

5804

dprintk("<-- %s\n", __func__);

5774

}

5805

}

5775

5806

5776

static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {

5807

static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {

5777

.rpc_call_prepare = nfs4_layoutreturn_prepare,

5808

.rpc_call_prepare = nfs4_layoutreturn_prepare,

5778

.rpc_call_done = nfs4_layoutreturn_done,

5809

.rpc_call_done = nfs4_layoutreturn_done,

5779

.rpc_release = nfs4_layoutreturn_release,

5810

.rpc_release = nfs4_layoutreturn_release,

5780

};

5811

};

5781

5812

5782

int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)

5813

int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)

5783

{

5814

{

5784

struct rpc_task *task;

5815

struct rpc_task *task;

5785

struct rpc_message msg = {

5816

struct rpc_message msg = {

5786

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],

5817

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],

5787

.rpc_argp = &lrp->args,

5818

.rpc_argp = &lrp->args,

5788

.rpc_resp = &lrp->res,

5819

.rpc_resp = &lrp->res,

5789

};

5820

};

5790

struct rpc_task_setup task_setup_data = {

5821

struct rpc_task_setup task_setup_data = {

5791

.rpc_client = lrp->clp->cl_rpcclient,

5822

.rpc_client = lrp->clp->cl_rpcclient,

5792

.rpc_message = &msg,

5823

.rpc_message = &msg,

5793

.callback_ops = &nfs4_layoutreturn_call_ops,

5824

.callback_ops = &nfs4_layoutreturn_call_ops,

5794

.callback_data = lrp,

5825

.callback_data = lrp,

5795

};

5826

};

5796

int status;

5827

int status;

5797

5828

5798

dprintk("--> %s\n", __func__);

5829

dprintk("--> %s\n", __func__);

5799

task = rpc_run_task(&task_setup_data);

5830

task = rpc_run_task(&task_setup_data);

5800

if (IS_ERR(task))

5831

if (IS_ERR(task))

5801

return PTR_ERR(task);

5832

return PTR_ERR(task);

5802

status = task->tk_status;

5833

status = task->tk_status;

5803

dprintk("<-- %s status=%d\n", __func__, status);

5834

dprintk("<-- %s status=%d\n", __func__, status);

5804

rpc_put_task(task);

5835

rpc_put_task(task);

5805

return status;

5836

return status;

5806

}

5837

}

5807

5838

5808

static int

5839

static int

5809

_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)

5840

_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)

5810

{

5841

{

5811

struct nfs4_getdeviceinfo_args args = {

5842

struct nfs4_getdeviceinfo_args args = {

5812

.pdev = pdev,

5843

.pdev = pdev,

5813

};

5844

};

5814

struct nfs4_getdeviceinfo_res res = {

5845

struct nfs4_getdeviceinfo_res res = {

5815

.pdev = pdev,

5846

.pdev = pdev,

5816

};

5847

};

5817

struct rpc_message msg = {

5848

struct rpc_message msg = {

5818

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],

5849

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],

5819

.rpc_argp = &args,

5850

.rpc_argp = &args,

5820

.rpc_resp = &res,

5851

.rpc_resp = &res,

5821

};

5852

};

5822

int status;

5853

int status;

5823

5854

5824

dprintk("--> %s\n", __func__);

5855

dprintk("--> %s\n", __func__);

5825

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

5856

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

5826

dprintk("<-- %s status=%d\n", __func__, status);

5857

dprintk("<-- %s status=%d\n", __func__, status);

5827

5858

5828

return status;

5859

return status;

5829

}

5860

}

5830

5861

5831

int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)

5862

int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)

5832

{

5863

{

5833

struct nfs4_exception exception = { };

5864

struct nfs4_exception exception = { };

5834

int err;

5865

int err;

5835

5866

5836

do {

5867

do {

5837

err = nfs4_handle_exception(server,

5868

err = nfs4_handle_exception(server,

5838

_nfs4_proc_getdeviceinfo(server, pdev),

5869

_nfs4_proc_getdeviceinfo(server, pdev),

5839

&exception);

5870

&exception);

5840

} while (exception.retry);

5871

} while (exception.retry);

5841

return err;

5872

return err;

5842

}

5873

}

5843

EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);

5874

EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);

5844

5875

5845

static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)

5876

static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)

5846

{

5877

{

5847

struct nfs4_layoutcommit_data *data = calldata;

5878

struct nfs4_layoutcommit_data *data = calldata;

5848

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

5879

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

5849

5880

5850

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

5881

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

5851

&data->res.seq_res, 1, task))

5882

&data->res.seq_res, 1, task))

5852

return;

5883

return;

5853

rpc_call_start(task);

5884

rpc_call_start(task);

5854

}

5885

}

5855

5886

5856

static void

5887

static void

5857

nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)

5888

nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)

5858

{

5889

{

5859

struct nfs4_layoutcommit_data *data = calldata;

5890

struct nfs4_layoutcommit_data *data = calldata;

5860

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

5891

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

5861

5892

5862

if (!nfs4_sequence_done(task, &data->res.seq_res))

5893

if (!nfs4_sequence_done(task, &data->res.seq_res))

5863

return;

5894

return;

5864

5895

5865

switch (task->tk_status) { /* Just ignore these failures */

5896

switch (task->tk_status) { /* Just ignore these failures */

5866

case NFS4ERR_DELEG_REVOKED: /* layout was recalled */

5897

case NFS4ERR_DELEG_REVOKED: /* layout was recalled */

5867

case NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */

5898

case NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */

5868

case NFS4ERR_BADLAYOUT: /* no layout */

5899

case NFS4ERR_BADLAYOUT: /* no layout */

5869

case NFS4ERR_GRACE: /* loca_recalim always false */

5900

case NFS4ERR_GRACE: /* loca_recalim always false */

5870

task->tk_status = 0;

5901

task->tk_status = 0;

5871

}

5902

}

5872

5903

5873

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5904

if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {

5874

nfs_restart_rpc(task, server->nfs_client);

5905

nfs_restart_rpc(task, server->nfs_client);

5875

return;

5906

return;

5876

}

5907

}

5877

5908

5878

if (task->tk_status == 0)

5909

if (task->tk_status == 0)

5879

nfs_post_op_update_inode_force_wcc(data->args.inode,

5910

nfs_post_op_update_inode_force_wcc(data->args.inode,

5880

data->res.fattr);

5911

data->res.fattr);

5881

}

5912

}

5882

5913

5883

static void nfs4_layoutcommit_release(void *calldata)

5914

static void nfs4_layoutcommit_release(void *calldata)

5884

{

5915

{

5885

struct nfs4_layoutcommit_data *data = calldata;

5916

struct nfs4_layoutcommit_data *data = calldata;

5886

5917

5887

/* Matched by references in pnfs_set_layoutcommit */

5918

/* Matched by references in pnfs_set_layoutcommit */

5888

put_lseg(data->lseg);

5919

put_lseg(data->lseg);

5889

put_rpccred(data->cred);

5920

put_rpccred(data->cred);

5890

kfree(data);

5921

kfree(data);

5891

}

5922

}

5892

5923

5893

static const struct rpc_call_ops nfs4_layoutcommit_ops = {

5924

static const struct rpc_call_ops nfs4_layoutcommit_ops = {

5894

.rpc_call_prepare = nfs4_layoutcommit_prepare,

5925

.rpc_call_prepare = nfs4_layoutcommit_prepare,

5895

.rpc_call_done = nfs4_layoutcommit_done,

5926

.rpc_call_done = nfs4_layoutcommit_done,

5896

.rpc_release = nfs4_layoutcommit_release,

5927

.rpc_release = nfs4_layoutcommit_release,

5897

};

5928

};

5898

5929

5899

int

5930

int

5900

nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)

5931

nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)

5901

{

5932

{

5902

struct rpc_message msg = {

5933

struct rpc_message msg = {

5903

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],

5934

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],

5904

.rpc_argp = &data->args,

5935

.rpc_argp = &data->args,

5905

.rpc_resp = &data->res,

5936

.rpc_resp = &data->res,

5906

.rpc_cred = data->cred,

5937

.rpc_cred = data->cred,

5907

};

5938

};

5908

struct rpc_task_setup task_setup_data = {

5939

struct rpc_task_setup task_setup_data = {

5909

.task = &data->task,

5940

.task = &data->task,

5910

.rpc_client = NFS_CLIENT(data->args.inode),

5941

.rpc_client = NFS_CLIENT(data->args.inode),

5911

.rpc_message = &msg,

5942

.rpc_message = &msg,

5912

.callback_ops = &nfs4_layoutcommit_ops,

5943

.callback_ops = &nfs4_layoutcommit_ops,

5913

.callback_data = data,

5944

.callback_data = data,

5914

.flags = RPC_TASK_ASYNC,

5945

.flags = RPC_TASK_ASYNC,

5915

};

5946

};

5916

struct rpc_task *task;

5947

struct rpc_task *task;

5917

int status = 0;

5948

int status = 0;

5918

5949

5919

dprintk("NFS: %4d initiating layoutcommit call. sync %d "

5950

dprintk("NFS: %4d initiating layoutcommit call. sync %d "

5920

"lbw: %llu inode %lu\n",

5951

"lbw: %llu inode %lu\n",

5921

data->task.tk_pid, sync,

5952

data->task.tk_pid, sync,

5922

data->args.lastbytewritten,

5953

data->args.lastbytewritten,

5923

data->args.inode->i_ino);

5954

data->args.inode->i_ino);

5924

5955

5925

task = rpc_run_task(&task_setup_data);

5956

task = rpc_run_task(&task_setup_data);

5926

if (IS_ERR(task))

5957

if (IS_ERR(task))

5927

return PTR_ERR(task);

5958

return PTR_ERR(task);

5928

if (sync == false)

5959

if (sync == false)

5929

goto out;

5960

goto out;

5930

status = nfs4_wait_for_completion_rpc_task(task);

5961

status = nfs4_wait_for_completion_rpc_task(task);

5931

if (status != 0)

5962

if (status != 0)

5932

goto out;

5963

goto out;

5933

status = task->tk_status;

5964

status = task->tk_status;

5934

out:

5965

out:

5935

dprintk("%s: status %d\n", __func__, status);

5966

dprintk("%s: status %d\n", __func__, status);

5936

rpc_put_task(task);

5967

rpc_put_task(task);

5937

return status;

5968

return status;

5938

}

5969

}

5939

5970

5940

static int

5971

static int

5941

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

5972

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

5942

struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)

5973

struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)

5943

{

5974

{

5944

struct nfs41_secinfo_no_name_args args = {

5975

struct nfs41_secinfo_no_name_args args = {

5945

.style = SECINFO_STYLE_CURRENT_FH,

5976

.style = SECINFO_STYLE_CURRENT_FH,

5946

};

5977

};

5947

struct nfs4_secinfo_res res = {

5978

struct nfs4_secinfo_res res = {

5948

.flavors = flavors,

5979

.flavors = flavors,

5949

};

5980

};

5950

struct rpc_message msg = {

5981

struct rpc_message msg = {

5951

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],

5982

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],

5952

.rpc_argp = &args,

5983

.rpc_argp = &args,

5953

.rpc_resp = &res,

5984

.rpc_resp = &res,

5954

};

5985

};

5955

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

5986

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

5956

}

5987

}

5957

5988

5958

static int

5989

static int

5959

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

5990

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

5960

struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)

5991

struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)

5961

{

5992

{

5962

struct nfs4_exception exception = { };

5993

struct nfs4_exception exception = { };

5963

int err;

5994

int err;

5964

do {

5995

do {

5965

err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);

5996

err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);

5966

switch (err) {

5997

switch (err) {

5967

case 0:

5998

case 0:

5968

case -NFS4ERR_WRONGSEC:

5999

case -NFS4ERR_WRONGSEC:

5969

case -NFS4ERR_NOTSUPP:

6000

case -NFS4ERR_NOTSUPP:

5970

break;

6001

break;

5971

default:

6002

default:

5972

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

6003

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

5973

}

6004

}

5974

} while (exception.retry);

6005

} while (exception.retry);

5975

return err;

6006

return err;

5976

}

6007

}

5977

6008

5978

static int

6009

static int

5979

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

6010

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

5980

struct nfs_fsinfo *info)

6011

struct nfs_fsinfo *info)

5981

{

6012

{

5982

int err;

6013

int err;

5983

struct page *page;

6014

struct page *page;

5984

rpc_authflavor_t flavor;

6015

rpc_authflavor_t flavor;

5985

struct nfs4_secinfo_flavors *flavors;

6016

struct nfs4_secinfo_flavors *flavors;

5986

6017

5987

page = alloc_page(GFP_KERNEL);

6018

page = alloc_page(GFP_KERNEL);

5988

if (!page) {

6019

if (!page) {

5989

err = -ENOMEM;

6020

err = -ENOMEM;

5990

goto out;

6021

goto out;

5991

}

6022

}

5992

6023

5993

flavors = page_address(page);

6024

flavors = page_address(page);

5994

err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);

6025

err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);

5995

6026

5996

/*

6027

/*

5997

* Fall back on "guess and check" method if

6028

* Fall back on "guess and check" method if

5998

* the server doesn't support SECINFO_NO_NAME

6029

* the server doesn't support SECINFO_NO_NAME

5999

*/

6030

*/

6000

if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) {

6031

if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) {

6001

err = nfs4_find_root_sec(server, fhandle, info);

6032

err = nfs4_find_root_sec(server, fhandle, info);

6002

goto out_freepage;

6033

goto out_freepage;

6003

}

6034

}

6004

if (err)

6035

if (err)

6005

goto out_freepage;

6036

goto out_freepage;

6006

6037

6007

flavor = nfs_find_best_sec(flavors);

6038

flavor = nfs_find_best_sec(flavors);

6008

if (err == 0)

6039

if (err == 0)

6009

err = nfs4_lookup_root_sec(server, fhandle, info, flavor);

6040

err = nfs4_lookup_root_sec(server, fhandle, info, flavor);

6010

6041

6011

out_freepage:

6042

out_freepage:

6012

put_page(page);

6043

put_page(page);

6013

if (err == -EACCES)

6044

if (err == -EACCES)

6014

return -EPERM;

6045

return -EPERM;

6015

out:

6046

out:

6016

return err;

6047

return err;

6017

}

6048

}

6018

static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)

6049

static int _nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)

6019

{

6050

{

6020

int status;

6051

int status;

6021

struct nfs41_test_stateid_args args = {

6052

struct nfs41_test_stateid_args args = {

6022

.stateid = &state->stateid,

6053

.stateid = &state->stateid,

6023

};

6054

};

6024

struct nfs41_test_stateid_res res;

6055

struct nfs41_test_stateid_res res;

6025

struct rpc_message msg = {

6056

struct rpc_message msg = {

6026

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],

6057

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],

6027

.rpc_argp = &args,

6058

.rpc_argp = &args,

6028

.rpc_resp = &res,

6059

.rpc_resp = &res,

6029

};

6060

};

6030

args.seq_args.sa_session = res.seq_res.sr_session = NULL;

6061

args.seq_args.sa_session = res.seq_res.sr_session = NULL;

6031

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

6062

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

6032

return status;

6063

return status;

6033

}

6064

}

6034

6065

6035

static int nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)

6066

static int nfs41_test_stateid(struct nfs_server *server, struct nfs4_state *state)

6036

{

6067

{

6037

struct nfs4_exception exception = { };

6068

struct nfs4_exception exception = { };

6038

int err;

6069

int err;

6039

do {

6070

do {

6040

err = nfs4_handle_exception(server,

6071

err = nfs4_handle_exception(server,

6041

_nfs41_test_stateid(server, state),

6072

_nfs41_test_stateid(server, state),

6042

&exception);

6073

&exception);

6043

} while (exception.retry);

6074

} while (exception.retry);

6044

return err;

6075

return err;

6045

}

6076

}

6046

6077

6047

static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *state)

6078

static int _nfs4_free_stateid(struct nfs_server *server, struct nfs4_state *state)

6048

{

6079

{

6049

int status;

6080

int status;

6050

struct nfs41_free_stateid_args args = {

6081

struct nfs41_free_stateid_args args = {

6051

.stateid = &state->stateid,

6082

.stateid = &state->stateid,

6052

};

6083

};

6053

struct nfs41_free_stateid_res res;

6084

struct nfs41_free_stateid_res res;

6054

struct rpc_message msg = {

6085

struct rpc_message msg = {

6055

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],

6086

.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],

6056

.rpc_argp = &args,

6087

.rpc_argp = &args,

6057

.rpc_resp = &res,

6088

.rpc_resp = &res,

6058

};

6089

};

6059

6090

6060

args.seq_args.sa_session = res.seq_res.sr_session = NULL;

6091

args.seq_args.sa_session = res.seq_res.sr_session = NULL;

6061

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

6092

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

6062

return status;

6093

return status;

6063

}

6094

}

6064

6095

6065

static int nfs41_free_stateid(struct nfs_server *server, struct nfs4_state *state)

6096

static int nfs41_free_stateid(struct nfs_server *server, struct nfs4_state *state)

6066

{

6097

{

6067

struct nfs4_exception exception = { };

6098

struct nfs4_exception exception = { };

6068

int err;

6099

int err;

6069

do {

6100

do {

6070

err = nfs4_handle_exception(server,

6101

err = nfs4_handle_exception(server,

6071

_nfs4_free_stateid(server, state),

6102

_nfs4_free_stateid(server, state),

6072

&exception);

6103

&exception);

6073

} while (exception.retry);

6104

} while (exception.retry);

6074

return err;

6105

return err;

6075

}

6106

}

6076

#endif /* CONFIG_NFS_V4_1 */

6107

#endif /* CONFIG_NFS_V4_1 */

6077

6108

6078

struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {

6109

struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {

6079

.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,

6110

.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,

6080

.state_flag_bit = NFS_STATE_RECLAIM_REBOOT,

6111

.state_flag_bit = NFS_STATE_RECLAIM_REBOOT,

6081

.recover_open = nfs4_open_reclaim,

6112

.recover_open = nfs4_open_reclaim,

6082

.recover_lock = nfs4_lock_reclaim,

6113

.recover_lock = nfs4_lock_reclaim,

6083

.establish_clid = nfs4_init_clientid,

6114

.establish_clid = nfs4_init_clientid,

6084

.get_clid_cred = nfs4_get_setclientid_cred,

6115

.get_clid_cred = nfs4_get_setclientid_cred,

6085

};

6116

};

6086

6117

6087

#if defined(CONFIG_NFS_V4_1)

6118

#if defined(CONFIG_NFS_V4_1)

6088

struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {

6119

struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {

6089

.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,

6120

.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,

6090

.state_flag_bit = NFS_STATE_RECLAIM_REBOOT,

6121

.state_flag_bit = NFS_STATE_RECLAIM_REBOOT,

6091

.recover_open = nfs4_open_reclaim,

6122

.recover_open = nfs4_open_reclaim,

6092

.recover_lock = nfs4_lock_reclaim,

6123

.recover_lock = nfs4_lock_reclaim,

6093

.establish_clid = nfs41_init_clientid,

6124

.establish_clid = nfs41_init_clientid,

6094

.get_clid_cred = nfs4_get_exchange_id_cred,

6125

.get_clid_cred = nfs4_get_exchange_id_cred,

6095

.reclaim_complete = nfs41_proc_reclaim_complete,

6126

.reclaim_complete = nfs41_proc_reclaim_complete,

6096

};

6127

};

6097

#endif /* CONFIG_NFS_V4_1 */

6128

#endif /* CONFIG_NFS_V4_1 */

6098

6129

6099

struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {

6130

struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {

6100

.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,

6131

.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,

6101

.state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,

6132

.state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,

6102

.recover_open = nfs4_open_expired,

6133

.recover_open = nfs4_open_expired,

6103

.recover_lock = nfs4_lock_expired,

6134

.recover_lock = nfs4_lock_expired,

6104

.establish_clid = nfs4_init_clientid,

6135

.establish_clid = nfs4_init_clientid,

6105

.get_clid_cred = nfs4_get_setclientid_cred,

6136

.get_clid_cred = nfs4_get_setclientid_cred,

6106

};

6137

};

6107

6138

6108

#if defined(CONFIG_NFS_V4_1)

6139

#if defined(CONFIG_NFS_V4_1)

6109

struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {

6140

struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {

6110

.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,

6141

.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,

6111

.state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,

6142

.state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,

6112

.recover_open = nfs4_open_expired,

6143

.recover_open = nfs41_open_expired,

6113

.recover_lock = nfs4_lock_expired,

6144

.recover_lock = nfs41_lock_expired,

6114

.establish_clid = nfs41_init_clientid,

6145

.establish_clid = nfs41_init_clientid,

6115

.get_clid_cred = nfs4_get_exchange_id_cred,

6146

.get_clid_cred = nfs4_get_exchange_id_cred,

6116

};

6147

};

6117

#endif /* CONFIG_NFS_V4_1 */

6148

#endif /* CONFIG_NFS_V4_1 */

6118

6149

6119

struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {

6150

struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {

6120

.sched_state_renewal = nfs4_proc_async_renew,

6151

.sched_state_renewal = nfs4_proc_async_renew,

6121

.get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,

6152

.get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,

6122

.renew_lease = nfs4_proc_renew,

6153

.renew_lease = nfs4_proc_renew,

6123

};

6154

};

6124

6155

6125

#if defined(CONFIG_NFS_V4_1)

6156

#if defined(CONFIG_NFS_V4_1)

6126

struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {

6157

struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {

6127

.sched_state_renewal = nfs41_proc_async_sequence,

6158

.sched_state_renewal = nfs41_proc_async_sequence,

6128

.get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,

6159

.get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,

6129

.renew_lease = nfs4_proc_sequence,

6160

.renew_lease = nfs4_proc_sequence,

6130

};

6161

};

6131

#endif

6162

#endif

6132

6163

6133

static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {

6164

static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {

6134

.minor_version = 0,

6165

.minor_version = 0,

6135

.call_sync = _nfs4_call_sync,

6166

.call_sync = _nfs4_call_sync,

6136

.validate_stateid = nfs4_validate_delegation_stateid,

6167

.validate_stateid = nfs4_validate_delegation_stateid,

6137

.find_root_sec = nfs4_find_root_sec,

6168

.find_root_sec = nfs4_find_root_sec,

6138

.reboot_recovery_ops = &nfs40_reboot_recovery_ops,

6169

.reboot_recovery_ops = &nfs40_reboot_recovery_ops,

6139

.nograce_recovery_ops = &nfs40_nograce_recovery_ops,

6170

.nograce_recovery_ops = &nfs40_nograce_recovery_ops,

6140

.state_renewal_ops = &nfs40_state_renewal_ops,

6171

.state_renewal_ops = &nfs40_state_renewal_ops,

6141

};

6172

};

6142

6173

6143

#if defined(CONFIG_NFS_V4_1)

6174

#if defined(CONFIG_NFS_V4_1)

6144

static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {

6175

static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {

6145

.minor_version = 1,

6176

.minor_version = 1,

6146

.call_sync = _nfs4_call_sync_session,

6177

.call_sync = _nfs4_call_sync_session,

6147

.validate_stateid = nfs41_validate_delegation_stateid,

6178

.validate_stateid = nfs41_validate_delegation_stateid,

6148

.find_root_sec = nfs41_find_root_sec,

6179

.find_root_sec = nfs41_find_root_sec,

6149

.reboot_recovery_ops = &nfs41_reboot_recovery_ops,

6180

.reboot_recovery_ops = &nfs41_reboot_recovery_ops,

6150

.nograce_recovery_ops = &nfs41_nograce_recovery_ops,

6181

.nograce_recovery_ops = &nfs41_nograce_recovery_ops,

6151

.state_renewal_ops = &nfs41_state_renewal_ops,

6182

.state_renewal_ops = &nfs41_state_renewal_ops,

6152

};

6183

};

6153

#endif

6184

#endif

6154

6185

6155

const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {

6186

const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {

6156

[0] = &nfs_v4_0_minor_ops,

6187

[0] = &nfs_v4_0_minor_ops,

6157

#if defined(CONFIG_NFS_V4_1)

6188

#if defined(CONFIG_NFS_V4_1)

6158

[1] = &nfs_v4_1_minor_ops,

6189

[1] = &nfs_v4_1_minor_ops,

6159

#endif

6190

#endif

6160

};

6191

};

6161

6192

6162

static const struct inode_operations nfs4_file_inode_operations = {

6193

static const struct inode_operations nfs4_file_inode_operations = {

6163

.permission = nfs_permission,

6194

.permission = nfs_permission,

6164

.getattr = nfs_getattr,

6195

.getattr = nfs_getattr,

6165

.setattr = nfs_setattr,

6196

.setattr = nfs_setattr,

6166

.getxattr = generic_getxattr,

6197

.getxattr = generic_getxattr,

6167

.setxattr = generic_setxattr,

6198

.setxattr = generic_setxattr,

6168

.listxattr = generic_listxattr,

6199

.listxattr = generic_listxattr,

6169

.removexattr = generic_removexattr,

6200

.removexattr = generic_removexattr,

6170

};

6201

};

6171

6202

6172

const struct nfs_rpc_ops nfs_v4_clientops = {

6203

const struct nfs_rpc_ops nfs_v4_clientops = {

6173

.version = 4, /* protocol version */

6204

.version = 4, /* protocol version */

6174

.dentry_ops = &nfs4_dentry_operations,

6205

.dentry_ops = &nfs4_dentry_operations,

6175

.dir_inode_ops = &nfs4_dir_inode_operations,

6206

.dir_inode_ops = &nfs4_dir_inode_operations,

6176

.file_inode_ops = &nfs4_file_inode_operations,

6207

.file_inode_ops = &nfs4_file_inode_operations,

6177

.getroot = nfs4_proc_get_root,

6208

.getroot = nfs4_proc_get_root,

6178

.getattr = nfs4_proc_getattr,

6209

.getattr = nfs4_proc_getattr,

6179

.setattr = nfs4_proc_setattr,

6210

.setattr = nfs4_proc_setattr,

6180

.lookupfh = nfs4_proc_lookupfh,

6211

.lookupfh = nfs4_proc_lookupfh,

6181

.lookup = nfs4_proc_lookup,

6212

.lookup = nfs4_proc_lookup,

6182

.access = nfs4_proc_access,

6213

.access = nfs4_proc_access,

6183

.readlink = nfs4_proc_readlink,

6214

.readlink = nfs4_proc_readlink,

6184

.create = nfs4_proc_create,

6215

.create = nfs4_proc_create,

6185

.remove = nfs4_proc_remove,

6216

.remove = nfs4_proc_remove,

6186

.unlink_setup = nfs4_proc_unlink_setup,

6217

.unlink_setup = nfs4_proc_unlink_setup,

6187

.unlink_done = nfs4_proc_unlink_done,

6218

.unlink_done = nfs4_proc_unlink_done,

6188

.rename = nfs4_proc_rename,

6219

.rename = nfs4_proc_rename,

6189

.rename_setup = nfs4_proc_rename_setup,

6220

.rename_setup = nfs4_proc_rename_setup,

6190

.rename_done = nfs4_proc_rename_done,

6221

.rename_done = nfs4_proc_rename_done,

6191

.link = nfs4_proc_link,

6222

.link = nfs4_proc_link,

6192

.symlink = nfs4_proc_symlink,

6223

.symlink = nfs4_proc_symlink,

6193

.mkdir = nfs4_proc_mkdir,

6224

.mkdir = nfs4_proc_mkdir,

6194

.rmdir = nfs4_proc_remove,

6225

.rmdir = nfs4_proc_remove,

6195

.readdir = nfs4_proc_readdir,

6226

.readdir = nfs4_proc_readdir,

6196

.mknod = nfs4_proc_mknod,

6227

.mknod = nfs4_proc_mknod,

6197

.statfs = nfs4_proc_statfs,

6228

.statfs = nfs4_proc_statfs,

6198

.fsinfo = nfs4_proc_fsinfo,

6229

.fsinfo = nfs4_proc_fsinfo,

6199

.pathconf = nfs4_proc_pathconf,

6230

.pathconf = nfs4_proc_pathconf,

6200

.set_capabilities = nfs4_server_capabilities,

6231

.set_capabilities = nfs4_server_capabilities,

6201

.decode_dirent = nfs4_decode_dirent,

6232

.decode_dirent = nfs4_decode_dirent,

6202

.read_setup = nfs4_proc_read_setup,

6233

.read_setup = nfs4_proc_read_setup,

6203

.read_done = nfs4_read_done,

6234

.read_done = nfs4_read_done,

6204

.write_setup = nfs4_proc_write_setup,

6235

.write_setup = nfs4_proc_write_setup,

6205

.write_done = nfs4_write_done,

6236

.write_done = nfs4_write_done,

6206

.commit_setup = nfs4_proc_commit_setup,

6237

.commit_setup = nfs4_proc_commit_setup,

6207

.commit_done = nfs4_commit_done,

6238

.commit_done = nfs4_commit_done,

6208

.lock = nfs4_proc_lock,

6239

.lock = nfs4_proc_lock,

6209

.clear_acl_cache = nfs4_zap_acl_attr,

6240

.clear_acl_cache = nfs4_zap_acl_attr,

6210

.close_context = nfs4_close_context,

6241

.close_context = nfs4_close_context,

6211

.open_context = nfs4_atomic_open,

6242

.open_context = nfs4_atomic_open,

6212

.init_client = nfs4_init_client,

6243

.init_client = nfs4_init_client,

6213

.secinfo = nfs4_proc_secinfo,

6244

.secinfo = nfs4_proc_secinfo,

6214

};

6245

};

6215

6246

6216

static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {

6247

static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {

6217

.prefix = XATTR_NAME_NFSV4_ACL,

6248

.prefix = XATTR_NAME_NFSV4_ACL,

6218

.list = nfs4_xattr_list_nfs4_acl,

6249

.list = nfs4_xattr_list_nfs4_acl,

6219

.get = nfs4_xattr_get_nfs4_acl,

6250

.get = nfs4_xattr_get_nfs4_acl,

6220

.set = nfs4_xattr_set_nfs4_acl,

6251

.set = nfs4_xattr_set_nfs4_acl,

6221

};

6252

};

6222

6253

6223

const struct xattr_handler *nfs4_xattr_handlers[] = {

6254

const struct xattr_handler *nfs4_xattr_handlers[] = {

6224

&nfs4_xattr_nfs4_acl_handler,

6255

&nfs4_xattr_nfs4_acl_handler,

6225

NULL

6256

NULL

6226

};

6257

};

6227

6258

6228

/*

6259

/*

6229

* Local variables:

6260

* Local variables:

6230

* c-basic-offset: 8

6261

* c-basic-offset: 8

6231

* End:

6262

* End:

6232

*/

6263

*/

6233

6264

GITLAB

NFS: test and free stateids during recovery