nfs: handle failure of nfs_get_lock_context in unlock path
Subsystems (2)
PATCH 1/1 nfs: handle failure of nfs_get_lock_context in unlock path
When memory is insufficient, the allocation of nfs_lock_context in nfs_get_lock_context() fails and returns -ENOMEM. If we mistakenly treat an nfs4_unlockdata structure (whose l_ctx member has been set to -ENOMEM) as valid and proceed to execute rpc_run_task(), this will trigger a NULL pointer dereference in nfs4_locku_prepare. For example:
BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---
Free the allocated nfs4_unlockdata when nfs_get_lock_context() fails and return NULL to terminate subsequent rpc_run_task, preventing NULL pointer dereference.
--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/nfs/nfs4proc.c +8 -1
@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode); p->arg.fl = &p->fl; p->arg.seqid = seqid;
@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx); - p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);
Signature · 1 line
2.31.1
Quoted 74 lines · Li Lingfeng
When memory is insufficient, the allocation of
nfs_lock_contextinnfs_get_lock_context()fails and returns-ENOMEM. If we mistakenly treat annfs4_unlockdatastructure (whosel_ctxmember has been set to-ENOMEM) as valid and proceed to executerpc_run_task(), this will trigger a NULL pointer dereference innfs4_locku_prepare. For example:BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---Free the allocated
nfs4_unlockdatawhennfs_get_lock_context()fails and return NULL to terminate subsequentrpc_run_task, preventing NULL pointer dereference.Fixes f30cb757f680 ("NFS: Always wait for I/O completion before unlock")Signed-off-by Li Lingfeng <[email protected]>--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/nfs/nfs4proc.c +8
-0@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode); p->arg.fl = &p->fl; p->arg.seqid = seqid;
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7095
Quoted 3 lines
fs/nfs/nfs4proc.c +0
-0@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx);
Not exactly the same problem, but get_nfs_open_context() can fail too. Does it need error handling for that as well?
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7098
Quoted 4 lines
fs/nfs/nfs4proc.c +0
-1- p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);
Good catch:
Quoted 72 lines · Jeff Layton
Quoted 71 lines · Li Lingfeng
When memory is insufficient, the allocation of
nfs_lock_contextinnfs_get_lock_context()fails and returns-ENOMEM. If we mistakenly treat annfs4_unlockdatastructure (whosel_ctxmember has been set to-ENOMEM) as valid and proceed to executerpc_run_task(), this will trigger a NULL pointer dereference innfs4_locku_prepare. For example:BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---Free the allocated
nfs4_unlockdatawhennfs_get_lock_context()fails and return NULL to terminate subsequentrpc_run_task, preventing NULL pointer dereference.Fixes f30cb757f680 ("NFS: Always wait for I/O completion before unlock")Signed-off-by Li Lingfeng <[email protected]>--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/nfs/nfs4proc.c +8
-0@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode);
Quoted 8 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7095
Quoted 6 lines
fs/nfs/nfs4proc.c +0
-0p->arg.fl = &p->fl; p->arg.seqid = seqid;@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx);Not exactly the same problem, but
get_nfs_open_context()can fail too. Does it need error handling for that as well?
Hi,
IIUC, nfs_open_context is allocated during file open and attached to filp->private_data. Upon successful file opening, the context remains valid. Post-lock acquisition, nfs_open_context can be retrieved via file_lock->file->nfs_open_context chain. Thus get_nfs_open_context() here should have non-failure guarantee in standard code paths.
Best regards,
Lingfeng
Quoted 9 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7098
Quoted 5 lines
fs/nfs/nfs4proc.c +0
-1- p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);Good catch:
Reviewed-by Jeff Layton <[email protected]>
Jeff Layton
maintainerQuoted 82 lines · Li Lingfeng
Quoted 72 lines · Jeff Layton
Quoted 71 lines · Li Lingfeng
When memory is insufficient, the allocation of
nfs_lock_contextinnfs_get_lock_context()fails and returns-ENOMEM. If we mistakenly treat annfs4_unlockdatastructure (whosel_ctxmember has been set to-ENOMEM) as valid and proceed to executerpc_run_task(), this will trigger a NULL pointer dereference innfs4_locku_prepare. For example:BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---Free the allocated
nfs4_unlockdatawhennfs_get_lock_context()fails and return NULL to terminate subsequentrpc_run_task, preventing NULL pointer dereference.Fixes f30cb757f680 ("NFS: Always wait for I/O completion before unlock")Signed-off-by Li Lingfeng <[email protected]>--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/nfs/nfs4proc.c +8
-0@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode);Quoted 8 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7095
Quoted 6 lines
fs/nfs/nfs4proc.c +0
-0p->arg.fl = &p->fl; p->arg.seqid = seqid;@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx);Not exactly the same problem, but
get_nfs_open_context()can fail too. Does it need error handling for that as well?
Quoted 7 lines
Hi,
IIUC,
nfs_open_contextis allocated during file open and attached tofilp->private_data. Upon successful file opening, the context remains valid. Post-lock acquisition,nfs_open_contextcan be retrieved viafile_lock->file->nfs_open_contextchain. Thusget_nfs_open_context()here should have non-failure guarantee in standard code paths.
I'm not so sure. This function can get called from the rpc_release callback for a LOCK request:
->rpc_release
nfs4_lock_release
nfs4_do_unlck
nfs4_alloc_unlockdata
Can that happen after the open_ctx->lock_context.count goes to 0?
Given that we have a safe failure path in this code, it seems like we ought to check for that here, just to be safe. If it really shouldn't happen like you say, then we could throw in a WARN_ON_ONCE() too.
Quoted 9 lines
Quoted 9 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7098
Quoted 5 lines
fs/nfs/nfs4proc.c +0
-1- p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);Good catch:
Reviewed-by Jeff Layton <[email protected]>
Signature · 1 line
Jeff Layton <[email protected]>
Quoted 98 lines · Jeff Layton
Quoted 81 lines · Li Lingfeng
Quoted 72 lines · Jeff Layton
Quoted 71 lines · Li Lingfeng
When memory is insufficient, the allocation of
nfs_lock_contextinnfs_get_lock_context()fails and returns-ENOMEM. If we mistakenly treat annfs4_unlockdatastructure (whosel_ctxmember has been set to-ENOMEM) as valid and proceed to executerpc_run_task(), this will trigger a NULL pointer dereference innfs4_locku_prepare. For example:BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---Free the allocated
nfs4_unlockdatawhennfs_get_lock_context()fails and return NULL to terminate subsequentrpc_run_task, preventing NULL pointer dereference.Fixes f30cb757f680 ("NFS: Always wait for I/O completion before unlock")Signed-off-by Li Lingfeng <[email protected]>--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/nfs/nfs4proc.c +8
-0@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode);Quoted 8 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7095
Quoted 6 lines
fs/nfs/nfs4proc.c +0
-0p->arg.fl = &p->fl; p->arg.seqid = seqid;@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx);Not exactly the same problem, but
get_nfs_open_context()can fail too. Does it need error handling for that as well?Quoted 7 lines
Hi,
IIUC,
nfs_open_contextis allocated during file open and attached tofilp->private_data. Upon successful file opening, the context remains valid. Post-lock acquisition,nfs_open_contextcan be retrieved viafile_lock->file->nfs_open_contextchain. Thusget_nfs_open_context()here should have non-failure guarantee in standard code paths.I'm not so sure. This function can get called from the
rpc_releasecallback for a LOCK request:->rpc_release
nfs4_lock_release
nfs4_do_unlck
nfs4_alloc_unlockdata
Quoted 5 lines
Can that happen after the
open_ctx->lock_context.countgoes to 0?Given that we have a safe failure path in this code, it seems like we ought to check for that here, just to be safe. If it really shouldn't happen like you say, then we could throw in a
WARN_ON_ONCE()too.
Thank you for raising this concern.
During file open, the nfs_open_context is allocated, and open_ctx->lock_context.count is initialized to 1. Based on the current flow, I think it's unlikely for this counter to reach 0 during lock/unlock operations since its decrement is tied to file closure.
However, I agree with your suggestion to add checks when get_nfs_open_context fails. Furthermore, this check might also be necessary not only in the unlock path but potentially in the lock path if get_nfs_open_contextb fails there as well.
Additionally, I noticed that both the lock and unlock release callbacks dereference nfs_open_context. If get_nfs_open_context were to fail (assuming such a scenario is possible), this could lead to a NULL pointer dereference. Instead of relying solely on WARN_ON_ONCE(), it might be safer to halt the operation immediately upon detecting a failure in get_nfs_open_context.
// unlocknfs4_locku_release_calldata
put_nfs_open_context
__put_nfs_open_context
// dereference nfs_open_context
// locknfs4_lock_release
nfs4_do_unlck
// dereference nfs_open_context
put_nfs_open_context
// dereference nfs_open_context
I'll incorporate your feedback and send a patchset soon.
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7098
Quoted 5 lines
fs/nfs/nfs4proc.c +0
-1- p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);Good catch:
Reviewed-by Jeff Layton <[email protected]>
Jeff Layton
maintainerQuoted 128 lines · Li Lingfeng
Quoted 98 lines · Jeff Layton
Quoted 81 lines · Li Lingfeng
Quoted 72 lines · Jeff Layton
Quoted 71 lines · Li Lingfeng
When memory is insufficient, the allocation of
nfs_lock_contextinnfs_get_lock_context()fails and returns-ENOMEM. If we mistakenly treat annfs4_unlockdatastructure (whosel_ctxmember has been set to-ENOMEM) as valid and proceed to executerpc_run_task(), this will trigger a NULL pointer dereference innfs4_locku_prepare. For example:BUG: kernel NULL pointer dereference, address: 000000000000000c PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 15 UID: 0 PID: 12 Comm: kworker/u64:0 Not tainted 6.15.0-rc2-dirty #60 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-2.fc40 Workqueue: rpciod rpc_async_schedule RIP: 0010:nfs4_locku_prepare+0x35/0xc2 Code: 89 f2 48 89 fd 48 c7 c7 68 69 ef b5 53 48 8b 8e 90 00 00 00 48 89 f3 RSP: 0018:ffffbbafc006bdb8 EFLAGS: 00010246 RAX: 000000000000004b RBX: ffff9b964fc1fa00 RCX: 0000000000000000 RDX: 0000000000000000 RSI: fffffffffffffff4 RDI: ffff9ba53fddbf40 RBP: ffff9ba539934000 R08: 0000000000000000 R09: ffffbbafc006bc38 R10: ffffffffb6b689c8 R11: 0000000000000003 R12: ffff9ba539934030 R13: 0000000000000001 R14: 0000000004248060 R15: ffffffffb56d1c30 FS: 0000000000000000(0000) GS:ffff9ba5881f0000(0000) knlGS:00000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 000000000000000c CR3: 000000093f244000 CR4: 00000000000006f0 Call Trace: <TASK> __rpc_execute+0xbc/0x480 rpc_async_schedule+0x2f/0x40 process_one_work+0x232/0x5d0 worker_thread+0x1da/0x3d0 ? __pfx_worker_thread+0x10/0x10 kthread+0x10d/0x240 ? __pfx_kthread+0x10/0x10 ret_from_fork+0x34/0x50 ? __pfx_kthread+0x10/0x10 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 000000000000000c ---[ end trace 0000000000000000 ]---Free the allocated
nfs4_unlockdatawhennfs_get_lock_context()fails and return NULL to terminate subsequentrpc_run_task, preventing NULL pointer dereference.Fixes f30cb757f680 ("NFS: Always wait for I/O completion before unlock")Signed-off-by Li Lingfeng <[email protected]>--- fs/nfs/nfs4proc.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/nfs/nfs4proc.c +8
-0@@ -7074,10 +7074,18 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct nfs4_state *state = lsp->ls_state;struct inode *inode = state->inode; +struct nfs_lock_context *l_ctx; p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; + l_ctx =nfs_get_lock_context (ctx); +if (!IS_ERR (l_ctx)) { + p->l_ctx = l_ctx; + }else { +kfree (p); +return NULL ; + } p->arg.fh =NFS_FH (inode);Quoted 8 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7095
Quoted 6 lines
fs/nfs/nfs4proc.c +0
-0p->arg.fl = &p->fl; p->arg.seqid = seqid;@@ -7085,7 +7093,6 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->lsp = lsp;/* Ensure we don't close file until we're done freeing locks! */ p->ctx =get_nfs_open_context (ctx);Not exactly the same problem, but
get_nfs_open_context()can fail too. Does it need error handling for that as well?Quoted 7 lines
Hi,
IIUC,
nfs_open_contextis allocated during file open and attached tofilp->private_data. Upon successful file opening, the context remains valid. Post-lock acquisition,nfs_open_contextcan be retrieved viafile_lock->file->nfs_open_contextchain. Thusget_nfs_open_context()here should have non-failure guarantee in standard code paths.I'm not so sure. This function can get called from the
rpc_releasecallback for a LOCK request:->rpc_release
nfs4_lock_release
nfs4_do_unlck
nfs4_alloc_unlockdataQuoted 5 lines
Can that happen after the
open_ctx->lock_context.countgoes to 0?Given that we have a safe failure path in this code, it seems like we ought to check for that here, just to be safe. If it really shouldn't happen like you say, then we could throw in a
WARN_ON_ONCE()too.Thank you for raising this concern.
During file open, thenfs_open_contextis allocated, andopen_ctx->lock_context.countis initialized to 1. Based on the current flow, I think it's unlikely for this counter to reach 0 during lock/unlock operations since its decrement is tied to file closure.However, I agree with your suggestion to add checks when
get_nfs_open_contextfails. Furthermore, this check might also be necessary not only in the unlock path but potentially in the lock path ifget_nfs_open_contextbfails there as well.Additionally, I noticed that both the lock and unlock release callbacks dereference
nfs_open_context. Ifget_nfs_open_contextwere to fail (assuming such a scenario is possible), this could lead to a NULL pointer dereference. Instead of relying solely onWARN_ON_ONCE(), it might be safer to halt the operation immediately upon detecting a failure inget_nfs_open_context.// unlock
nfs4_locku_release_calldata
put_nfs_open_context
__put_nfs_open_context
// dereferencenfs_open_context
Quoted 8 lines
// lock
nfs4_lock_release
nfs4_do_unlck
// dereferencenfs_open_context
put_nfs_open_context
// dereferencenfs_open_contextI'll incorporate your feedback and send a patchset soon.
Thanks. I think that it pays to be safe here. If this scenario turns out to not be possible, then the alternative would be to add a comment that explains why.
Just handling the error case is probably best though as this is not a particularly hot codepath, and that would help safeguard against future changes.
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
fs/nfs/nfs4proc.c static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, · line 7098
Quoted 5 lines
fs/nfs/nfs4proc.c +0
-1- p->l_ctx =nfs_get_lock_context (ctx);locks_init_lock (&p->fl);locks_copy_lock (&p->fl, fl); p->server =NFS_SERVER (inode);Good catch:
Reviewed-by Jeff Layton <[email protected]>
Signature · 1 line
Jeff Layton <[email protected]>