History

NFS: handle source server reboot

When the source server reboots after a server-to-server copy was issued, we need to retry the copy from COPY_NOTIFY. We need to detect that the source server rebooted and there is a copy waiting on a destination server and wake it up.

Olga Kornievskaia committed 7 years ago

Commit 0e65a321 parent fefa1a85 files · +75 −27Browse files

Unified · Split

5 files
  1. fs/nfs/nfs42proc.c +47 −21
  2. fs/nfs/nfs4_fs.h +1 −0
  3. fs/nfs/nfs4file.c +3 −0
  4. fs/nfs/nfs4state.c +21 −5
  5. include/linux/nfs_fs.h +3 −1
fs/nfs/nfs42proc.c+47−21
@@ -153,22 +153,26 @@ out_unlock: · 152 unmodified lines
153153 }
154154
155155 static int handle_async_copy(struct nfs42_copy_res *res,
156− struct nfs_server *server,
156+ struct nfs_server *dst_server,
157+ struct nfs_server *src_server,
157158 struct file *src,
158159 struct file *dst,
159− nfs4_stateid *src_stateid)
160+ nfs4_stateid *src_stateid,
161+ bool *restart)
160162 {
161163 struct nfs4_copy_state *copy, *tmp_copy;
162164 int status = NFS4_OK;
163165 bool found_pending = false;
164− struct nfs_open_context *ctx = nfs_file_open_context(dst);
166+ struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
167+ struct nfs_open_context *src_ctx = nfs_file_open_context(src);
165168
166169 copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
167170 if (!copy)
168171 return -ENOMEM;
169172
170− spin_lock(&server->nfs_client->cl_lock);
171− list_for_each_entry(tmp_copy, &server->nfs_client->pending_cb_stateids,
173+ spin_lock(&dst_server->nfs_client->cl_lock);
174+ list_for_each_entry(tmp_copy,
175+ &dst_server->nfs_client->pending_cb_stateids,
172176 copies) {
173177 if (memcmp(&res->write_res.stateid, &tmp_copy->stateid,
174178 NFS4_STATEID_SIZE))
@@ -178,7 +182,7 @@ static int handle_async_copy(struct nfs42_copy_res *res, · 3 unmodified lines
178182 break;
179183 }
180184 if (found_pending) {
181− spin_unlock(&server->nfs_client->cl_lock);
185+ spin_unlock(&dst_server->nfs_client->cl_lock);
182186 kfree(copy);
183187 copy = tmp_copy;
184188 goto out;
@@ -186,19 +190,32 @@ static int handle_async_copy(struct nfs42_copy_res *res, · 1 unmodified line
186190
187191 memcpy(&copy->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
188192 init_completion(&copy->completion);
189− copy->parent_state = ctx->state;
193+ copy->parent_dst_state = dst_ctx->state;
194+ copy->parent_src_state = src_ctx->state;
195+
196+ list_add_tail(&copy->copies, &dst_server->ss_copies);
197+ spin_unlock(&dst_server->nfs_client->cl_lock);
190198
191− list_add_tail(&copy->copies, &server->ss_copies);
192− spin_unlock(&server->nfs_client->cl_lock);
199+ if (dst_server != src_server) {
200+ spin_lock(&src_server->nfs_client->cl_lock);
201+ list_add_tail(&copy->src_copies, &src_server->ss_copies);
202+ spin_unlock(&src_server->nfs_client->cl_lock);
203+ }
193204
194205 status = wait_for_completion_interruptible(&copy->completion);
195− spin_lock(&server->nfs_client->cl_lock);
206+ spin_lock(&dst_server->nfs_client->cl_lock);
196207 list_del_init(&copy->copies);
197− spin_unlock(&server->nfs_client->cl_lock);
208+ spin_unlock(&dst_server->nfs_client->cl_lock);
209+ if (dst_server != src_server) {
210+ spin_lock(&src_server->nfs_client->cl_lock);
211+ list_del_init(&copy->src_copies);
212+ spin_unlock(&src_server->nfs_client->cl_lock);
213+ }
198214 if (status == -ERESTARTSYS) {
199215 goto out_cancel;
200− } else if (copy->flags) {
216+ } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
201217 status = -EAGAIN;
218+ *restart = true;
202219 goto out_cancel;
203220 }
204221 out:
@@ -247,7 +264,8 @@ static ssize_t _nfs42_proc_copy(struct file *src, · 42 unmodified lines
247264 struct nfs42_copy_args *args,
248265 struct nfs42_copy_res *res,
249266 struct nl4_server *nss,
250− nfs4_stateid *cnr_stateid)
267+ nfs4_stateid *cnr_stateid,
268+ bool *restart)
251269 {
252270 struct rpc_message msg = {
253271 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
@@ -255,7 +273,9 @@ static ssize_t _nfs42_proc_copy(struct file *src, · 1 unmodified line
255273 .rpc_resp = res,
256274 };
257275 struct inode *dst_inode = file_inode(dst);
258− struct nfs_server *server = NFS_SERVER(dst_inode);
276+ struct inode *src_inode = file_inode(src);
277+ struct nfs_server *dst_server = NFS_SERVER(dst_inode);
278+ struct nfs_server *src_server = NFS_SERVER(src_inode);
259279 loff_t pos_src = args->src_pos;
260280 loff_t pos_dst = args->dst_pos;
261281 size_t count = args->count;
@@ -291,13 +311,15 @@ static ssize_t _nfs42_proc_copy(struct file *src, · 29 unmodified lines
291311 if (!res->commit_res.verf)
292312 return -ENOMEM;
293313 }
314+ set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
315+ &src_lock->open_context->state->flags);
294316 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
295317 &dst_lock->open_context->state->flags);
296318
297− status = nfs4_call_sync(server->client, server, &msg,
319+ status = nfs4_call_sync(dst_server->client, dst_server, &msg,
298320 &args->seq_args, &res->seq_res, 0);
299321 if (status == -ENOTSUPP)
300− server->caps &= ~NFS_CAP_COPY;
322+ dst_server->caps &= ~NFS_CAP_COPY;
301323 if (status)
302324 goto out;
303325
@@ -309,8 +331,8 @@ static ssize_t _nfs42_proc_copy(struct file *src, · 5 unmodified lines
309331 }
310332
311333 if (!res->synchronous) {
312− status = handle_async_copy(res, server, src, dst,
313− &args->src_stateid);
334+ status = handle_async_copy(res, dst_server, src_server, src,
335+ dst, &args->src_stateid, restart);
314336 if (status)
315337 return status;
316338 }
@@ -358,6 +380,7 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, · 41 unmodified lines
358380 .stateid = &args.dst_stateid,
359381 };
360382 ssize_t err, err2;
383+ bool restart = false;
361384
362385 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
363386 if (IS_ERR(src_lock))
@@ -378,7 +401,7 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, · 14 unmodified lines
378401 err = _nfs42_proc_copy(src, src_lock,
379402 dst, dst_lock,
380403 &args, &res,
381− nss, cnr_stateid);
404+ nss, cnr_stateid, &restart);
382405 inode_unlock(file_inode(dst));
383406
384407 if (err >= 0)
@@ -388,8 +411,11 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, · 3 unmodified lines
388411 err = -EOPNOTSUPP;
389412 break;
390413 } else if (err == -EAGAIN) {
391− dst_exception.retry = 1;
392− continue;
414+ if (!restart) {
415+ dst_exception.retry = 1;
416+ continue;
417+ }
418+ break;
393419 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
394420 args.sync = true;
395421 dst_exception.retry = 1;
fs/nfs/nfs4_fs.h+1−0
@@ -168,6 +168,7 @@ enum { · 167 unmodified lines
168168 NFS_STATE_CHANGE_WAIT, /* A state changing operation is outstanding */
169169 #ifdef CONFIG_NFS_V4_2
170170 NFS_CLNT_DST_SSC_COPY_STATE, /* dst server open state on client*/
171+ NFS_CLNT_SRC_SSC_COPY_STATE, /* src server open state on client*/
171172 NFS_SRV_SSC_COPY_STATE, /* ssc state on the dst server */
172173 #endif /* CONFIG_NFS_V4_2 */
173174 };
fs/nfs/nfs4file.c+3−0
@@ -146,6 +146,7 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in, · 145 unmodified lines
146146 return -EOPNOTSUPP;
147147 if (file_inode(file_in) == file_inode(file_out))
148148 return -EOPNOTSUPP;
149+retry:
149150 if (!nfs42_files_from_same_server(file_in, file_out)) {
150151 cn_resp = kzalloc(sizeof(struct nfs42_copy_notify_res),
151152 GFP_NOFS);
@@ -164,6 +165,8 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in, · 12 unmodified lines
164165 nss, cnrs);
165166 out:
166167 kfree(cn_resp);
168+ if (ret == -EAGAIN)
169+ goto retry;
167170 return ret;
168171 }
169172
fs/nfs/nfs4state.c+21−5
@@ -1556,16 +1556,32 @@ static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state · 1555 unmodified lines
15561556 {
15571557 struct nfs4_copy_state *copy;
15581558
1559− if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags))
1559+ if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1560+ !test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
15601561 return;
15611562
15621563 spin_lock(&sp->so_server->nfs_client->cl_lock);
15631564 list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
1564− if (!nfs4_stateid_match_other(&state->stateid, &copy->parent_state->stateid))
1565− continue;
1565+ if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1566+ !nfs4_stateid_match_other(&state->stateid,
1567+ &copy->parent_dst_state->stateid)))
1568+ continue;
15661569 copy->flags = 1;
1567− complete(&copy->completion);
1568− break;
1570+ if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1571+ &state->flags)) {
1572+ clear_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags);
1573+ complete(&copy->completion);
1574+ }
1575+ }
1576+ list_for_each_entry(copy, &sp->so_server->ss_copies, src_copies) {
1577+ if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1578+ !nfs4_stateid_match_other(&state->stateid,
1579+ &copy->parent_src_state->stateid)))
1580+ continue;
1581+ copy->flags = 1;
1582+ if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1583+ &state->flags))
1584+ complete(&copy->completion);
15691585 }
15701586 spin_unlock(&sp->so_server->nfs_client->cl_lock);
15711587 }
include/linux/nfs_fs.h+3−1
@@ -189,13 +189,15 @@ struct nfs_inode { · 188 unmodified lines
189189
190190 struct nfs4_copy_state {
191191 struct list_head copies;
192+ struct list_head src_copies;
192193 nfs4_stateid stateid;
193194 struct completion completion;
194195 uint64_t count;
195196 struct nfs_writeverf verf;
196197 int error;
197198 int flags;
198− struct nfs4_state *parent_state;
199+ struct nfs4_state *parent_src_state;
200+ struct nfs4_state *parent_dst_state;
199201 };
200202
201203 /*

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t