Skip to contentSkip to conversation

block: Fix spelling mistake in comments

PATCH In review Zhang Jiaming 4 participants 9 messages Jul 4, 2022 – Aug 26, 2022 MD RAID

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 block: Fix spelling mistake in comments

There are some typos(dones't, waitting) in comments. Fix it.

---
 drivers/md/raid5-cache.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/md/raid5-cache.c +4 -4
index 83c184eddbda..4b799005eb6e 100644
@@ -125,7 +125,7 @@ struct r5l_log {
 					 * reclaimed.  if it's 0, reclaim spaces
 					 * used by io_units which are in
 					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
 					 * switching to IO_UNIT_STRIPE_END
 					 * state) */
 	wait_queue_head_t iounit_wait;
@@ -1327,9 +1327,9 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
 	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-	 * for all IO finish, hence waitting for reclaim thread, while reclaim
-	 * thread is calling this function and waitting for reconfig mutex. So
+	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
+	 * for all IO finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
 	 * FIXME: we could miss discard if we can't take reconfig mutex
 	 */
Signature · 1 line
2.34.1
Reviewed-by on v1 1/1
#1 lore raw

Dear Zhang,

Thank you for your patch. Some nits.

Am 04.07.22 um 03:23 schrieb Zhang Jiaming:

Quoted 2 lines

There are some typos(dones't, waitting) in comments. Fix it.

Please add a space before the (. “Fix it.” also fits on the line above, and maybe use plural in the commit message summary. For the body, maybe:

Fix spelling of dones't and waitting in comments.

Quoted 21 lines
---
  drivers/md/raid5-cache.c | 8 ++++----
  1 file changed, 4 insertions(+), 4 deletions(-)
drivers/md/raid5-cache.c +1 -1
index 83c184eddbda..4b799005eb6e 100644
@@ -125,7 +125,7 @@ struct r5l_log {
  					 * reclaimed.  if it's 0, reclaim spaces
  					 * used by io_units which are in
  					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
  					 * switching to IO_UNIT_STRIPE_END
  					 * state) */
  	wait_queue_head_t iounit_wait;
@@ -1327,9 +1327,9 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
  	 * superblock is updated to new log tail. Updating superblock (either
  	 * directly call md_update_sb() or depend on md thread) must hold

drivers/md/raid5-cache.c static void r5l_write_super_and_discard_space(struct r5l_log *log, · line 1335

Quoted 10 lines
drivers/md/raid5-cache.c +3 -3
  	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-	 * for all IO finish, hence waitting for reclaim thread, while reclaim
-	 * thread is calling this function and waitting for reconfig mutex. So
+	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
+	 * for all IO finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig mutex. So
  	 * there is a deadlock. We workaround this issue with a trylock.
  	 * FIXME: we could miss discard if we can't take reconfig mutex
  	 */

Kind regards,

Paul

#2 lore raw

PATCH 1/1 block: Fix spelling mistakes in comments

In reply to Zhang Jiaming

Fix spelling of dones't and waitting in comments.

---
 drivers/md/raid5-cache.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/md/raid5-cache.c +4 -4
index 83c184eddbda..4b799005eb6e 100644
@@ -125,7 +125,7 @@ struct r5l_log {
 					 * reclaimed.  if it's 0, reclaim spaces
 					 * used by io_units which are in
 					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
 					 * switching to IO_UNIT_STRIPE_END
 					 * state) */
 	wait_queue_head_t iounit_wait;
@@ -1327,9 +1327,9 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
 	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-	 * for all IO finish, hence waitting for reclaim thread, while reclaim
-	 * thread is calling this function and waitting for reconfig mutex. So
+	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
+	 * for all IO finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
 	 * FIXME: we could miss discard if we can't take reconfig mutex
 	 */
Signature · 1 line
2.34.1
#3 lore raw

Re: [PATCH] block: Fix spelling mistakes in comments

Quoted 1 line · Zhang Jiaming

Fix spelling of dones't and waitting in comments.

Version your patches, you're now at v2. [PATCH v2] ...

Please find a few suggestions below as to what can be fixed in this block of text as you're making a pass over it.

drivers/md/raid5-cache.c static void r5l_write_super_and_discard_space(struct r5l_log *log, · line 1330

Quoted 8 lines
drivers/md/raid5-cache.c +1 -3
@@ -1327,9 +1327,9 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
 	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-	 * for all IO finish, hence waitting for reclaim thread, while reclaim
-	 * thread is calling this function and waitting for reconfig mutex. So
+	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting

held

drivers/md/raid5-cache.c static void r5l_write_super_and_discard_space(struct r5l_log *log, · line 1331

Quoted 1 line
drivers/md/raid5-cache.c +1 -0
+	 * for all IO finish, hence waiting for reclaim thread, while reclaim

all IO to finish

drivers/md/raid5-cache.c static void r5l_write_super_and_discard_space(struct r5l_log *log, · line 1335

Quoted 4 lines
drivers/md/raid5-cache.c +1 -0
+	 * thread is calling this function and waiting for reconfig mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
 	 * FIXME: we could miss discard if we can't take reconfig mutex
 	 */

There are several mentions of 'reconfig mutex' that should probably be 'reconfig_mutex'. What's the correct way to refer to a mutex in comments like the above?

Daniel K.

#4 lore raw

PATCH v2 1/1 block: Fix spelling mistakes in comments

In reply to Zhang Jiaming

Fix spelling of dones't and waitting in comments. Fix tense mistakes of hold and finsh in comments. Use underline to connecting reconfig and mutex.

---
 drivers/md/raid5-cache.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/md/raid5-cache.c +6 -6
index 83c184eddbda..8d5154d94f86 100644
@@ -125,7 +125,7 @@ struct r5l_log {
 					 * reclaimed.  if it's 0, reclaim spaces
 					 * used by io_units which are in
 					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
 					 * switching to IO_UNIT_STRIPE_END
 					 * state) */
 	wait_queue_head_t iounit_wait;
@@ -1326,12 +1326,12 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * Discard could zero data, so before discard we must make sure
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
-	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-	 * for all IO finish, hence waitting for reclaim thread, while reclaim
-	 * thread is calling this function and waitting for reconfig mutex. So
+	 * reconfig_mutex. On the other hand, raid5_quiesce is called with
+	 * reconfig_mutex held. The first step of raid5_quiesce() is waiting
+	 * for all IO to finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig_mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
-	 * FIXME: we could miss discard if we can't take reconfig mutex
+	 * FIXME: we could miss discard if we can't take reconfig_mutex
 	 */
 	set_mask_bits(&mddev->sb_flags, 0,
 		BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING));
Signature · 1 line
2.34.1
maintainer
#5 lore raw

Re: [PATCH v2] block: Fix spelling mistakes in comments

Quoted 7 lines · Zhang Jiaming

Fix spelling of dones't and waitting in comments. Fix tense mistakes of hold and finsh in comments. Use underline to connecting reconfig and mutex.

Sorry for getting on this late.

AFAICT, this one doesn't apply any more (conflict with some of your other fixes). Could you please resend?

Thanks,
Song

Quoted 38 lines
---
 drivers/md/raid5-cache.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/md/raid5-cache.c +6 -7
index 83c184eddbda..8d5154d94f86 100644
@@ -125,7 +125,7 @@ struct r5l_log {
                                         * reclaimed.  if it's 0, reclaim spaces
                                         * used by io_units which are in
                                         * IO_UNIT_STRIPE_END state (eg, reclaim
-                                        * dones't wait for specific io_unit
+                                        * doesn't wait for specific io_unit
                                         * switching to IO_UNIT_STRIPE_END
                                         * state) */
        wait_queue_head_t iounit_wait;
@@ -1326,12 +1326,12 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
         * Discard could zero data, so before discard we must make sure
         * superblock is updated to new log tail. Updating superblock (either
         * directly call md_update_sb() or depend on md thread) must hold
-        * reconfig mutex. On the other hand, raid5_quiesce is called with
-        * reconfig_mutex hold. The first step of raid5_quiesce() is waitting
-        * for all IO finish, hence waitting for reclaim thread, while reclaim
-        * thread is calling this function and waitting for reconfig mutex. So
+        * reconfig_mutex. On the other hand, raid5_quiesce is called with
+        * reconfig_mutex held. The first step of raid5_quiesce() is waiting
+        * for all IO to finish, hence waiting for reclaim thread, while reclaim
+        * thread is calling this function and waiting for reconfig_mutex. So
         * there is a deadlock. We workaround this issue with a trylock.
-        * FIXME: we could miss discard if we can't take reconfig mutex
+        * FIXME: we could miss discard if we can't take reconfig_mutex
         */
        set_mask_bits(&mddev->sb_flags, 0,
                BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING));
--

2.34.1

#6 lore raw

PATCH v3 1/1 md/raid5-cache: Resolve patch confilcts

In reply to Zhang Jiaming

Resolve conflicts when applying patches.

---
 drivers/md/raid5-cache.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/md/raid5-cache.c +6 -6
index 058d82e..a4a84a0 100644
@@ -125,7 +125,7 @@ struct r5l_log {
 					 * reclaimed.  if it's 0, reclaim spaces
 					 * used by io_units which are in
 					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
 					 * switching to IO_UNIT_STRIPE_END
 					 * state) */
 	wait_queue_head_t iounit_wait;
@@ -1326,12 +1326,12 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * Discard could zero data, so before discard we must make sure
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
-	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
-	 * for all IO finish, hence waiting for reclaim thread, while reclaim
-	 * thread is calling this function and waiting for reconfig mutex. So
+	 * reconfig_mutex. On the other hand, raid5_quiesce is called with
+	 * reconfig_mutex held. The first step of raid5_quiesce() is waiting
+	 * for all IO to finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig_mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
-	 * FIXME: we could miss discard if we can't take reconfig mutex
+	 * FIXME: we could miss discard if we can't take reconfig_mutex
 	 */
 	set_mask_bits(&mddev->sb_flags, 0,
 		BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING));
Signature · 1 line
2.11.0
maintainer
#7 lore raw

Re: [PATCH v3] md/raid5-cache: Resolve patch confilcts

Quoted 2 lines · Zhang Jiaming

Resolve conflicts when applying patches.

^^^^^^ this is not a proper commit log. If we need something that is part of the patch/email, but not part of the commit log, we can add below

Quoted 2 lines
Signed-off-by ...

---
git-am will remove the message here (between two '---').
---
drivers/md/raid5-cache.c | 12 ++++++------

Quoted 38 lines
---
 drivers/md/raid5-cache.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/md/raid5-cache.c +6 -7
index 058d82e..a4a84a0 100644
@@ -125,7 +125,7 @@ struct r5l_log {
                                         * reclaimed.  if it's 0, reclaim spaces
                                         * used by io_units which are in
                                         * IO_UNIT_STRIPE_END state (eg, reclaim
-                                        * dones't wait for specific io_unit
+                                        * doesn't wait for specific io_unit
                                         * switching to IO_UNIT_STRIPE_END
                                         * state) */
        wait_queue_head_t iounit_wait;
@@ -1326,12 +1326,12 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
         * Discard could zero data, so before discard we must make sure
         * superblock is updated to new log tail. Updating superblock (either
         * directly call md_update_sb() or depend on md thread) must hold
-        * reconfig mutex. On the other hand, raid5_quiesce is called with
-        * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
-        * for all IO finish, hence waiting for reclaim thread, while reclaim
-        * thread is calling this function and waiting for reconfig mutex. So
+        * reconfig_mutex. On the other hand, raid5_quiesce is called with
+        * reconfig_mutex held. The first step of raid5_quiesce() is waiting
+        * for all IO to finish, hence waiting for reclaim thread, while reclaim
+        * thread is calling this function and waiting for reconfig_mutex. So
         * there is a deadlock. We workaround this issue with a trylock.
-        * FIXME: we could miss discard if we can't take reconfig mutex
+        * FIXME: we could miss discard if we can't take reconfig_mutex
         */
        set_mask_bits(&mddev->sb_flags, 0,
                BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING));
--

2.11.0

#8 lore raw

PATCH v3 1/1 block: Fix spelling mistakes in comments

In reply to Zhang Jiaming

Fix spelling of dones't and waitting in comments.
Fix tense mistakes of hold and finsh in comments.
Use underline to connecting reconfig and mutex.

---
v3: Resolve conflicts when applying patches.
---

---
 drivers/md/raid5-cache.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/md/raid5-cache.c +6 -6
index 058d82e..a4a84a0 100644
@@ -125,7 +125,7 @@ struct r5l_log {
 					 * reclaimed.  if it's 0, reclaim spaces
 					 * used by io_units which are in
 					 * IO_UNIT_STRIPE_END state (eg, reclaim
-					 * dones't wait for specific io_unit
+					 * doesn't wait for specific io_unit
 					 * switching to IO_UNIT_STRIPE_END
 					 * state) */
 	wait_queue_head_t iounit_wait;
@@ -1326,12 +1326,12 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,
 	 * Discard could zero data, so before discard we must make sure
 	 * superblock is updated to new log tail. Updating superblock (either
 	 * directly call md_update_sb() or depend on md thread) must hold
-	 * reconfig mutex. On the other hand, raid5_quiesce is called with
-	 * reconfig_mutex hold. The first step of raid5_quiesce() is waiting
-	 * for all IO finish, hence waiting for reclaim thread, while reclaim
-	 * thread is calling this function and waiting for reconfig mutex. So
+	 * reconfig_mutex. On the other hand, raid5_quiesce is called with
+	 * reconfig_mutex held. The first step of raid5_quiesce() is waiting
+	 * for all IO to finish, hence waiting for reclaim thread, while reclaim
+	 * thread is calling this function and waiting for reconfig_mutex. So
 	 * there is a deadlock. We workaround this issue with a trylock.
-	 * FIXME: we could miss discard if we can't take reconfig mutex
+	 * FIXME: we could miss discard if we can't take reconfig_mutex
 	 */
 	set_mask_bits(&mddev->sb_flags, 0,
 		BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING));
Signature · 1 line
2.11.0