fs: record task name which froze superblock
Subsystems (3)
PATCH 1/1 fs: record task name which froze superblock
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take task_struct reference) to make support engineer's life easier.
Hopefully 16 bytes per superblock isn't much.
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.
---
fs/ioctl.c | 22 ++++++++++++++++------ fs/super.c | 2 ++ include/linux/fs.h | 2 ++ 3 files changed, 20 insertions(+), 6 deletions(-)
fs/ioctl.c +16 -6
@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ -if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv; }static int ioctl_fsthaw (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;/* Thaw */ -if (sb->s_op->thaw_super) -return sb->s_op->thaw_super (sb); -return thaw_super (sb); +if (sb->s_op->thaw_super) { + rv = sb->s_op->thaw_super (sb); +if (rv ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else + rv =thaw_super (sb); +return rv; }/*
fs/super.c +2 -0
@@ -1355,6 +1355,7 @@ int freeze_super(struct super_block *sb)* sees write activity when frozen is set to SB_FREEZE_COMPLETE. */ sb->s_writers.frozen =SB_FREEZE_COMPLETE ; +get_task_comm (sb->s_writers.freeze_comm, current);up_write (&sb->s_umount);return 0 ; }
@@ -1391,6 +1392,7 @@ int thaw_super(struct super_block *sb) out: sb->s_writers.frozen =SB_UNFROZEN ; +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN );smp_wmb ();wake_up (&sb->s_writers.wait_unfrozen);deactivate_locked_super (sb);
include/linux/fs.h +2 -0
@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map lock_map[SB_FREEZE_LEVELS ];#endif
Jan Kara
reviewerQuoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.Signed-off-by Alexey Dobriyan <[email protected]>
Hum, and when do you show the task name? Or do you expect that customer
takes a crashdump and support just finds it in memory?
Quoted 21 lines
---
fs/ioctl.c | 22 ++++++++++++++++------ fs/super.c | 2 ++ include/linux/fs.h | 2 ++ 3 files changed, 20 insertions(+), 6 deletions(-)fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */
fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 10 lines
fs/ioctl.c +7
-3-if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;
Why don't you just set the name in ioctl_fsfreeze() in both cases?
Also you seem to be missing freezing / thawing in freeze/thaw_bdev() functions.
Quoted 45 lines
fs/ioctl.c +8
-3}static int ioctl_fsthaw (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;/* Thaw */ -if (sb->s_op->thaw_super) -return sb->s_op->thaw_super (sb); -return thaw_super (sb); +if (sb->s_op->thaw_super) { + rv = sb->s_op->thaw_super (sb); +if (rv ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else + rv =thaw_super (sb); +return rv; }/* fs/super.c +2
-0@@ -1355,6 +1355,7 @@ int freeze_super(struct super_block *sb)* sees write activity when frozen is set to SB_FREEZE_COMPLETE. */ sb->s_writers.frozen =SB_FREEZE_COMPLETE ; +get_task_comm (sb->s_writers.freeze_comm, current);up_write (&sb->s_umount);return 0 ; }@@ -1391,6 +1392,7 @@ int thaw_super(struct super_block *sb) out: sb->s_writers.frozen =SB_UNFROZEN ; +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN );smp_wmb ();wake_up (&sb->s_writers.wait_unfrozen);deactivate_locked_super (sb);
include/linux/fs.h struct sb_writers { · line 1225
Quoted 5 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];
Here should be TASK_COMM_LEN, shouldn't it?
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Quoted 6 lines · Jan Kara
Quoted 5 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take
task_structreference) to make support engineer's life easier.
Quoted 8 lines
Quoted 6 lines
Hopefully 16 bytes per superblock isn't much.
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.Signed-off-by Alexey Dobriyan <[email protected]>Hum, and when do you show the task name? Or do you expect that customer
takes a crashdump and support just finds it in memory?
Yeah, having at least something in crashdump is fine.
Quoted 13 lines
Quoted 13 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;
Quoted 12 lines
fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 11 lines
fs/ioctl.c +7
-3/* Freeze */ -if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?
There are users of freeze_super() in GFS2 unless I'm misreading code.
Quoted 2 lines
Also you seem to be missing freezing / thawing in freeze/thaw_bdev() functions.
You are correct. Resending patch (blockdev freezing tested with XFS).
Quoted 9 lines
include/linux/fs.h struct sb_writers { · line 1225
Quoted 8 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];Here should be
TASK_COMM_LEN, shouldn't it?
It will pull sched.h, dunno if we care about headers anymore.
Alexey
PATCH v2 1/1 fs: record task name which froze superblock
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take task_struct reference) to make support engineer's life easier.
Hopefully 16 bytes per superblock isn't much.
---
fs/block_dev.c | 12 ++++++++---- fs/ioctl.c | 22 ++++++++++++++++------ fs/super.c | 2 ++ include/linux/fs.h | 2 ++ 4 files changed, 28 insertions(+), 10 deletions(-)
fs/block_dev.c +8 -4
@@ -227,9 +227,11 @@ struct super_block *freeze_bdev(struct block_device *bdev) sb =get_active_super (bdev);if (!sb) goto out; -if (sb->s_op->freeze_super) +if (sb->s_op->freeze_super) { error = sb->s_op->freeze_super (sb); -else +if (error ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else error =freeze_super (sb);if (error) {deactivate_super (sb);
@@ -267,9 +269,11 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb)if (!sb) goto out; -if (sb->s_op->thaw_super) +if (sb->s_op->thaw_super) { error = sb->s_op->thaw_super (sb); -else +if (error ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else error =thaw_super (sb);if (error) { bdev->bd_fsfreeze_count++;
fs/ioctl.c +16 -6
@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ -if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv; }static int ioctl_fsthaw (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;/* Thaw */ -if (sb->s_op->thaw_super) -return sb->s_op->thaw_super (sb); -return thaw_super (sb); +if (sb->s_op->thaw_super) { + rv = sb->s_op->thaw_super (sb); +if (rv ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else + rv =thaw_super (sb); +return rv; }/*
fs/super.c +2 -0
@@ -1355,6 +1355,7 @@ int freeze_super(struct super_block *sb)* sees write activity when frozen is set to SB_FREEZE_COMPLETE. */ sb->s_writers.frozen =SB_FREEZE_COMPLETE ; +get_task_comm (sb->s_writers.freeze_comm, current);up_write (&sb->s_umount);return 0 ; }
@@ -1391,6 +1392,7 @@ int thaw_super(struct super_block *sb) out: sb->s_writers.frozen =SB_UNFROZEN ; +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN );smp_wmb ();wake_up (&sb->s_writers.wait_unfrozen);deactivate_locked_super (sb);
include/linux/fs.h +2 -0
@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock and forgot to thaw it */ +char freeze_comm[16 ];#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map lock_map[SB_FREEZE_LEVELS ];#endif
Jan Kara
reviewerQuoted 9 lines · Alexey Dobriyan
Quoted 8 lines · Jan Kara
Quoted 7 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.Signed-off-by Alexey Dobriyan <[email protected]>Hum, and when do you show the task name? Or do you expect that customer
takes a crashdump and support just finds it in memory?Yeah, having at least something in crashdump is fine.
OK, then comment about this at freeze_comm[] definition so that it's
clear it isn't just set-but-never-read field.
Quoted 26 lines
Quoted 13 lines
Quoted 13 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;Quoted 12 lines
fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 11 lines
fs/ioctl.c +7
-3/* Freeze */ -if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?
Quoted 1 line
There are users of
freeze_super()in GFS2 unless I'm misreading code.
Yes, there are. The call in fs/gfs2/glops.c is in a call path from
->freeze_super() handler for GFS2 so that one is handled in ioctl_fsfreeze() anyway. The call in fs/gfs2/sys.c is a way to freeze filesystem via sysfs (dunno why GFS2 has to invent its own thing and ioctl isn't enough). Steven? So having the logic in ioctl_fsfreeze(), freeze_bdev() and freeze_store() in gfs2 seems to be enough.
Quoted 15 lines
Quoted 2 lines
Also you seem to be missing freezing / thawing in freeze/thaw_bdev() functions.
You are correct. Resending patch (blockdev freezing tested with XFS).
Quoted 9 lines
include/linux/fs.h struct sb_writers { · line 1225
Quoted 8 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];Here should be
TASK_COMM_LEN, shouldn't it?
Quoted 1 line
It will pull
sched.h, dunno if we care about headers anymore.
That's not ideal but IMHO better than having the value hardcoded here.
That is pretty fragile - i.e. think what happens when someone decides to increase TASK_COMM_LEN...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Hi,
Quoted 45 lines · Jan Kara
Quoted 9 lines · Alexey Dobriyan
Quoted 8 lines · Jan Kara
Quoted 7 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
Quoted 7 lines
Quoted 6 lines
Quoted 4 lines
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.Signed-off-by Alexey Dobriyan <[email protected]>Hum, and when do you show the task name? Or do you expect that customer
takes a crashdump and support just finds it in memory?Yeah, having at least something in crashdump is fine.
OK, then comment about this at freeze_comm[] definition so that it's
clear it isn't just set-but-never-read field.Quoted 25 lines
Quoted 25 lines
Quoted 14 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 10 lines
fs/ioctl.c +7
-3-if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?
Quoted 8 lines
Quoted 1 line
There are users of
freeze_super()in GFS2 unless I'm misreading code.Yes, there are. The call in
fs/gfs2/glops.cis in a call path from
->freeze_super() handler for GFS2 so that one is handled inioctl_fsfreeze()anyway. The call infs/gfs2/sys.cis a way to freeze filesystem via sysfs (dunno why GFS2 has to invent its own thing and ioctl isn't enough). Steven? So having the logic inioctl_fsfreeze(),freeze_bdev()andfreeze_store()in gfs2 seems to be enough.
The sysfs freeze thing is historical and strongly deprecated - I hope that we may be able to remove it one day,
Steve.
Quoted 13 lines · Jan Kara
Quoted 12 lines · Alexey Dobriyan
Quoted 11 lines · Jan Kara
Quoted 10 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. Record at least task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
P.S.: Cc'ing GFS2 people just in case they want to correct my understanding of GFS2 having async freeze code.
Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
Signed-off-by Alexey Dobriyan <[email protected]>Hum, and when do you show the task name? Or do you expect that customer
takes a crashdump and support just finds it in memory?Yeah, having at least something in crashdump is fine.
OK, then comment about this at freeze_comm[] definition so that it's
clear it isn't just set-but-never-read field.
OK.
Quoted 26 lines
Quoted 26 lines
Quoted 25 lines
Quoted 14 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 10 lines
fs/ioctl.c +7
-3-if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?
Quoted 7 lines
Quoted 1 line
There are users of
freeze_super()in GFS2 unless I'm misreading code.Yes, there are. The call in
fs/gfs2/glops.cis in a call path from
->freeze_super() handler for GFS2 so that one is handled inioctl_fsfreeze()anyway. The call infs/gfs2/sys.cis a way to freeze filesystem via sysfs (dunno why GFS2 has to invent its own thing and ioctl isn't enough). Steven? So having the logic inioctl_fsfreeze(),freeze_bdev()andfreeze_store()in gfs2 seems to be enough.
Jan, my logic is as follows.
Recording freezer task name is not filesystem/device specific and thus should be done in generic code. So no changes in GFS2.
freeze_super() is generic counterpart to filesystem/device specific ->freeze_super() hook, look how they are paired. It should recore freezer task name, so any future user will not forget to do the same.
So it's in ioctl_fsfreeze(), freeze_bdev() and freeze_super().
Quoted 10 lines
Quoted 10 lines
Quoted 9 lines
include/linux/fs.h struct sb_writers { · line 1225
Quoted 8 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];Here should be
TASK_COMM_LEN, shouldn't it?
Quoted 4 lines
Quoted 1 line
It will pull
sched.h, dunno if we care about headers anymore.That's not ideal but IMHO better than having the value hardcoded here.
That is pretty fragile - i.e. think what happens when someone decides to increaseTASK_COMM_LEN...
TASK_COMM_LEN is userspace ABI via at least prctl(PR_SET_NAME). I can formally move it to include/uapi/linux/sched.h. This allows to not drag sched.h into fs.h for one tiny define.
Alexey
Jan Kara
reviewerQuoted 40 lines · Alexey Dobriyan
Quoted 26 lines · Jan Kara
Quoted 26 lines
Quoted 25 lines
Quoted 14 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 10 lines
fs/ioctl.c +7
-3-if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?Quoted 7 lines
Quoted 1 line
There are users of
freeze_super()in GFS2 unless I'm misreading code.Yes, there are. The call in
fs/gfs2/glops.cis in a call path from
->freeze_super() handler for GFS2 so that one is handled inioctl_fsfreeze()anyway. The call infs/gfs2/sys.cis a way to freeze filesystem via sysfs (dunno why GFS2 has to invent its own thing and ioctl isn't enough). Steven? So having the logic inioctl_fsfreeze(),freeze_bdev()andfreeze_store()in gfs2 seems to be enough.Jan, my logic is as follows.
Recording freezer task name is not filesystem/device specific and thus should be done in generic code. So no changes in GFS2.
Quoted 6 lines
freeze_super()is generic counterpart to filesystem/device specific ->freeze_super() hook, look how they are paired. It should recore freezer task name, so any future user will not forget to do the same.So it's in
ioctl_fsfreeze(),freeze_bdev()andfreeze_super().
Well, but this stores the name in two different levels - once in the top
level (ioctl_fsfreeze(), freeze_bdev()) and once in a place called from there (freeze_super()). That just seems wrong to me. You can just record the frozen process in freeze_super() and mandate that if someone manages to freeze the fs without calling freeze_super() from his ->freeze_super() handler (currently there isn't such filesystem), he is also responsible for setting freezer name... Hmm?
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 9 lines
include/linux/fs.h struct sb_writers { · line 1225
Quoted 8 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];Here should be
TASK_COMM_LEN, shouldn't it?
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
It will pull
sched.h, dunno if we care about headers anymore.That's not ideal but IMHO better than having the value hardcoded here.
That is pretty fragile - i.e. think what happens when someone decides to increaseTASK_COMM_LEN...
TASK_COMM_LENis userspace ABI via at leastprctl(PR_SET_NAME). I can formally move it toinclude/uapi/linux/sched.h. This allows to not dragsched.hintofs.hfor one tiny define.
OK, moving the definition would be preferable to me (and IMO also a
cleanup).
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Quoted 46 lines · Jan Kara
Quoted 45 lines · Alexey Dobriyan
Quoted 26 lines · Jan Kara
Quoted 26 lines
Quoted 25 lines
Quoted 14 lines
fs/ioctl.c +1
-0@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ fs/ioctl.c static int ioctl_fsfreeze(struct file *filp) · line 537
Quoted 10 lines
fs/ioctl.c +7
-3-if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv;Why don't you just set the name in
ioctl_fsfreeze()in both cases?Quoted 7 lines
Quoted 1 line
There are users of
freeze_super()in GFS2 unless I'm misreading code.Yes, there are. The call in
fs/gfs2/glops.cis in a call path from
->freeze_super() handler for GFS2 so that one is handled inioctl_fsfreeze()anyway. The call infs/gfs2/sys.cis a way to freeze filesystem via sysfs (dunno why GFS2 has to invent its own thing and ioctl isn't enough). Steven? So having the logic inioctl_fsfreeze(),freeze_bdev()andfreeze_store()in gfs2 seems to be enough.Jan, my logic is as follows.
Recording freezer task name is not filesystem/device specific and thus should be done in generic code. So no changes in GFS2.
freeze_super()is generic counterpart to filesystem/device specific ->freeze_super() hook, look how they are paired. It should recore freezer task name, so any future user will not forget to do the same.
Quoted 8 lines
Quoted 1 line
So it's in
ioctl_fsfreeze(),freeze_bdev()andfreeze_super().Well, but this stores the name in two different levels - once in the top
level (ioctl_fsfreeze(),freeze_bdev()) and once in a place called from there (freeze_super()). That just seems wrong to me. You can just record the frozen process infreeze_super()and mandate that if someone manages to freeze the fs without callingfreeze_super()from his ->freeze_super() handler (currently there isn't such filesystem), he is also responsible for setting freezer name... Hmm?
Jan I understand you. But I find stranger that GFS will have to record freezer name.
I'm sending v3, hopefully final.
Quoted 20 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 9 lines
include/linux/fs.h struct sb_writers { · line 1225
Quoted 8 lines
include/linux/fs.h +2
-0@@ -1221,6 +1221,8 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* who froze superblock */ +char freeze_comm[16 ];Here should be
TASK_COMM_LEN, shouldn't it?Quoted 8 lines
Quoted 4 lines
Quoted 1 line
It will pull
sched.h, dunno if we care about headers anymore.That's not ideal but IMHO better than having the value hardcoded here.
That is pretty fragile - i.e. think what happens when someone decides to increaseTASK_COMM_LEN...
TASK_COMM_LENis userspace ABI via at leastprctl(PR_SET_NAME). I can formally move it toinclude/uapi/linux/sched.h. This allows to not dragsched.hintofs.hfor one tiny define.OK, moving the definition would be preferable to me (and IMO also a
cleanup).
PATCH v3 1/1 fs: record task name which froze superblock
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take task_struct reference) to make support engineer's life easier.
Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LEN definition (which is userspace ABI, see prctl(PR_SET_NAME)) is moved to userspace exported header to not drag sched.h into every fs.h inclusion.
---
fs/block_dev.c | 12 ++++++++---- fs/ioctl.c | 22 ++++++++++++++++------ fs/super.c | 2 ++ include/linux/fs.h | 6 ++++++ include/linux/sched.h | 3 --- include/uapi/linux/sched.h | 3 +++ 6 files changed, 35 insertions(+), 13 deletions(-)
fs/block_dev.c +8 -4
@@ -227,9 +227,11 @@ struct super_block *freeze_bdev(struct block_device *bdev) sb =get_active_super (bdev);if (!sb) goto out; -if (sb->s_op->freeze_super) +if (sb->s_op->freeze_super) { error = sb->s_op->freeze_super (sb); -else +if (error ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else error =freeze_super (sb);if (error) {deactivate_super (sb);
@@ -267,9 +269,11 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb)if (!sb) goto out; -if (sb->s_op->thaw_super) +if (sb->s_op->thaw_super) { error = sb->s_op->thaw_super (sb); -else +if (error ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else error =thaw_super (sb);if (error) { bdev->bd_fsfreeze_count++;
fs/ioctl.c +16 -6
@@ -518,6 +518,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,static int ioctl_fsfreeze (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;
@@ -527,22 +528,31 @@ static int ioctl_fsfreeze(struct file *filp)return -EOPNOTSUPP ;/* Freeze */ -if (sb->s_op->freeze_super) -return sb->s_op->freeze_super (sb); -return freeze_super (sb); +if (sb->s_op->freeze_super) { + rv = sb->s_op->freeze_super (sb); +if (rv ==0 ) +get_task_comm (sb->s_writers.freeze_comm, current); + }else + rv =freeze_super (sb); +return rv; }static int ioctl_fsthaw (struct file *filp) {struct super_block *sb =file_inode (filp)->i_sb; +int rv;if (!capable (CAP_SYS_ADMIN ))return -EPERM ;/* Thaw */ -if (sb->s_op->thaw_super) -return sb->s_op->thaw_super (sb); -return thaw_super (sb); +if (sb->s_op->thaw_super) { + rv = sb->s_op->thaw_super (sb); +if (rv ==0 ) +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN ); + }else + rv =thaw_super (sb); +return rv; }/*
fs/super.c +2 -0
@@ -1351,6 +1351,7 @@ int freeze_super(struct super_block *sb)* sees write activity when frozen is set to SB_FREEZE_COMPLETE. */ sb->s_writers.frozen =SB_FREEZE_COMPLETE ; +get_task_comm (sb->s_writers.freeze_comm, current);up_write (&sb->s_umount);return 0 ; }
@@ -1387,6 +1388,7 @@ int thaw_super(struct super_block *sb) out: sb->s_writers.frozen =SB_UNFROZEN ; +memset (sb->s_writers.freeze_comm,0 ,TASK_COMM_LEN );smp_wmb ();wake_up (&sb->s_writers.wait_unfrozen);deactivate_locked_super (sb);
include/linux/fs.h +6 -0
@@ -33,6 +33,7 @@#include <asm/byteorder.h> #include <uapi/linux/fs.h> +#include <uapi/linux/sched.h> struct backing_dev_info ;struct export_operations ;
@@ -1217,6 +1218,11 @@ struct sb_writers {int frozen;/* Is sb frozen? */ wait_queue_head_t wait_unfrozen;/* queue for waiting for sb to be thawed */ +/* +* who froze superblock +* write-only field for traces in crashdump +*/ +char freeze_comm[TASK_COMM_LEN ];#ifdef CONFIG_DEBUG_LOCK_ALLOC struct lockdep_map lock_map[SB_FREEZE_LEVELS ];#endif
include/linux/sched.h +0 -3
@@ -303,9 +303,6 @@ extern char ___assert_task_state[1 - 2*!!(#endif -/* Task command name length */ -#define TASK_COMM_LEN 16 -#include <linux/spinlock.h> /*
include/uapi/linux/sched.h +3 -0
@@ -49,4 +49,7 @@*/ #define SCHED_FLAG_RESET_ON_FORK 0x01 +/* Task command name length */ +#define TASK_COMM_LEN 16 +#endif /* _UAPI_LINUX_SCHED_H */
Quoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LENdefinition (which is userspace ABI, seeprctl(PR_SET_NAME)) is moved to userspace exported header to not dragsched.hinto everyfs.hinclusion.Signed-off-by Alexey Dobriyan <[email protected]>
Freeze/thaw can be nested at the block level. That means the sb->s_writers.freeze_comm can point at the wrong process. i.e.
Task A Task Bfreeze_bdev
freeze_super
freeze_comm = A
freeze_bdev
.....thaw_bdev
<device still frozen>
<crash>
At this point, the block device will never be unthawed, but the debug field is now pointing to the wrong task. i.e. The debug helper has not recorded the process that is actually causing the problem, and leads us all off on a wild goose chase down the wrong path.
IMO, debug code is only useful if it's reliable.....
Quoted 15 lines
include/linux/sched.h +0
-3@@ -303,9 +303,6 @@ extern char ___assert_task_state[1 - 2*!!(#endif -/* Task command name length */ -#define TASK_COMM_LEN 16 -#include <linux/spinlock.h> /*
include/uapi/linux/sched.h line 55
Quoted 7 lines
include/uapi/linux/sched.h +3
-0@@ -49,4 +49,7 @@*/ #define SCHED_FLAG_RESET_ON_FORK 0x01 +/* Task command name length */ +#define TASK_COMM_LEN 16 +#endif /* _UAPI_LINUX_SCHED_H */
That should be a separate patch, sent to the scheduler maintainers for review. AFAICT, it isn't part of the user API - it's not defined in the man page which just says "can be up to 16 bytes".
Cheers,
Dave.
Signature · 2 lines
Dave Chinner david at fromorbit.com
Quoted 26 lines · Dave Chinner
Quoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LENdefinition (which is userspace ABI, seeprctl(PR_SET_NAME)) is moved to userspace exported header to not dragsched.hinto everyfs.hinclusion.Signed-off-by Alexey Dobriyan <[email protected]>Freeze/thaw can be nested at the block level. That means the
sb->s_writers.freeze_commcan point at the wrong process. i.e.Task A Task B
freeze_bdev
freeze_super
freeze_comm= A
freeze_bdev
.....thaw_bdev
<device still frozen><crash>
Quoted 8 lines
At this point, the block device will never be unthawed, but the debug field is now pointing to the wrong task. i.e. The debug helper has not recorded the process that is actually causing the problem, and leads us all off on a wild goose chase down the wrong path.
IMO, debug code is only useful if it's reliable.....
It can be trivially modified to be very useful to support people.
Actually this patch clears saved task name on unfreeze, so in this particular scenario we would end up with no data.
Freezer and unfreezer names don't even have to match, so there is not much we can do here (e.g. recording all names in a linked list or something is a non-starter because of this).
I propose the following:
- on freezing:
1. if 0->1 save the name
2. if 1->2 have a flag to note there is an additional freezer
- on unfreezing
1. if 1->0 clear the flag
2. DO NOT clear the name in any case
This way we keep the name for possible future reference and we know whether something with this name was the sole freezer in this cycle.
As explained below, this one task name is already very useful and likely covers majority of real life use cases.
While working in support we were getting a lot of vmcores where hung task detector panicked the kernel because a lot of tasks were blocked in UN state trying to write to frozen filesystems. I presume OP has similar story.
Some back on forth commuication almost always revealed one process e.g. freezing stuff and then blocking itself trying to access it. While we could see it blocked, we had no presumptive evidence to pin freezing on it. A matching name, while still not 100% conclusive, would be ok enough to push the case forward and avoid a rountrip of systemap scripts showing freezer process tree.
Signature · 1 line
Mateusz Guzik
Quoted 45 lines · Mateusz Guzik
Quoted 26 lines · Dave Chinner
Quoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LENdefinition (which is userspace ABI, seeprctl(PR_SET_NAME)) is moved to userspace exported header to not dragsched.hinto everyfs.hinclusion.Signed-off-by Alexey Dobriyan <[email protected]>Freeze/thaw can be nested at the block level. That means the
sb->s_writers.freeze_commcan point at the wrong process. i.e.Task A Task B
freeze_bdev
freeze_super
freeze_comm= A
freeze_bdev
.....thaw_bdev
<device still frozen><crash>Quoted 8 lines
At this point, the block device will never be unthawed, but the debug field is now pointing to the wrong task. i.e. The debug helper has not recorded the process that is actually causing the problem, and leads us all off on a wild goose chase down the wrong path.
IMO, debug code is only useful if it's reliable.....
It can be trivially modified to be very useful to support people.
Actually this patch clears saved task name on unfreeze, so in this particular scenario we would end up with no data.
Freezer and unfreezer names don't even have to match, so there is not much we can do here (e.g. recording all names in a linked list or something is a non-starter because of this).
Quoted 8 lines
I propose the following:
- on freezing:
1. if 0->1 save the name
2. if 1->2 have a flag to note there is an additional freezer
- on unfreezing
1. if 1->0 clear the flag
2. DO NOT clear the name in any case
Now that I sent this e-mail I realized we could actually keep a linked list of freezer names. Unfreezing would delete all elements when going 1->0, but would not touch it otherwise.
This would cover a less likely use case though, so I would be fine either way FWIW.
Just my $0,03.
Quoted 18 lines
This way we keep the name for possible future reference and we know whether something with this name was the sole freezer in this cycle.
As explained below, this one task name is already very useful and likely covers majority of real life use cases.
While working in support we were getting a lot of vmcores where hung task detector panicked the kernel because a lot of tasks were blocked in UN state trying to write to frozen filesystems. I presume OP has similar story.
Some back on forth commuication almost always revealed one process e.g. freezing stuff and then blocking itself trying to access it. While we could see it blocked, we had no presumptive evidence to pin freezing on it. A matching name, while still not 100% conclusive, would be ok enough to push the case forward and avoid a rountrip of systemap scripts showing freezer process tree.
Signature · 1 line
Mateusz Guzik
Quoted 55 lines · Mateusz Guzik
Quoted 45 lines · Mateusz Guzik
Quoted 26 lines · Dave Chinner
Quoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LENdefinition (which is userspace ABI, seeprctl(PR_SET_NAME)) is moved to userspace exported header to not dragsched.hinto everyfs.hinclusion.Signed-off-by Alexey Dobriyan <[email protected]>Freeze/thaw can be nested at the block level. That means the
sb->s_writers.freeze_commcan point at the wrong process. i.e.Task A Task B
freeze_bdev
freeze_super
freeze_comm= A
freeze_bdev
.....thaw_bdev
<device still frozen><crash>Quoted 8 lines
At this point, the block device will never be unthawed, but the debug field is now pointing to the wrong task. i.e. The debug helper has not recorded the process that is actually causing the problem, and leads us all off on a wild goose chase down the wrong path.
IMO, debug code is only useful if it's reliable.....
It can be trivially modified to be very useful to support people.
Actually this patch clears saved task name on unfreeze, so in this particular scenario we would end up with no data.
Freezer and unfreezer names don't even have to match, so there is not much we can do here (e.g. recording all names in a linked list or something is a non-starter because of this).
Quoted 8 lines
I propose the following:
- on freezing:
1. if 0->1 save the name
2. if 1->2 have a flag to note there is an additional freezer
- on unfreezing
1. if 1->0 clear the flag
2. DO NOT clear the name in any case
Quoted 3 lines
Now that I sent this e-mail I realized we could actually keep a linked list of freezer names. Unfreezing would delete all elements when going 1->0, but would not touch it otherwise.
If you do linked list two processes constantly keeping superblock frozen will allocate all the memory:
F
F
T
F
T
...
After all valid objections and comments I think the way to proceed is
a) record freeze_comm, never clear it (maybe record thaw_comm)
b) record "i am not the only one" flag
c) introduce debug_freeze which will "record" everything in dmesg for situations when crashdump is not used but serial console is.
Alexey
Quoted 33 lines · Mateusz Guzik
Quoted 32 lines · Dave Chinner
Quoted 11 lines · Alexey Dobriyan
Freezing and thawing are separate system calls, task which is supposed to thaw filesystem/superblock can disappear due to crash or not thaw due to a bug. At least record task name (we can't take
task_structreference) to make support engineer's life easier.Hopefully 16 bytes per superblock isn't much.
TASK_COMM_LENdefinition (which is userspace ABI, seeprctl(PR_SET_NAME)) is moved to userspace exported header to not dragsched.hinto everyfs.hinclusion.Signed-off-by Alexey Dobriyan <[email protected]>Freeze/thaw can be nested at the block level. That means the
sb->s_writers.freeze_commcan point at the wrong process. i.e.Task A Task B
freeze_bdev
freeze_super
freeze_comm= A
freeze_bdev
.....thaw_bdev
<device still frozen><crash>At this point, the block device will never be unthawed, but the debug field is now pointing to the wrong task. i.e. The debug helper has not recorded the process that is actually causing the problem, and leads us all off on a wild goose chase down the wrong path.
Quoted 7 lines
Quoted 2 lines
IMO, debug code is only useful if it's reliable.....
It can be trivially modified to be very useful to support people.
Actually this patch clears saved task name on unfreeze, so in this particular scenario we would end up with no data.
It only clears it i thaw_super(), which is *not called* until the last nested thaw_bdev() call is made.
When the system is hung what we actually need to know is who is responsible for *thawing* the filesystem and then we can work out why that hasn't run. What this code tries to do is identify who froze the filesystem and so indicate who *might* be responsible for thawing it. If we mis-identify the agent who holds the freeze status, then we fail to identify who needs to run the thaw and hence we're still stuck not knowing WTF happened....
I understand why you want to record this - I'm not arguing that we shouldn't do this. My point is that we should *make it reliable* and not in any way ambiguous, otherwise we failed to solve the problem it was intended for.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner david at fromorbit.com
Quoted 7 lines · Mateusz Guzik
As explained below, this one task name is already very useful and likely covers majority of real life use cases.
While working in support we were getting a lot of vmcores where hung task detector panicked the kernel because a lot of tasks were blocked in UN state trying to write to frozen filesystems. I presume OP has similar story.
Yes, the intended "use" case is 1 freezer which hopefully covers majority of bug reports.
Quoted 6 lines
Some back on forth commuication almost always revealed one process e.g. freezing stuff and then blocking itself trying to access it. While we could see it blocked, we had no presumptive evidence to pin freezing on it. A matching name, while still not 100% conclusive, would be ok enough to push the case forward and avoid a rountrip of systemap scripts showing freezer process tree.