Pointer compare in md driver

Pointer compare in md driver

[wuzhouhui]

Hi,

Sorry for disturbing, but I have consider this problem for several days.
I have a question when reading md driver. Following is the code from
linux/drivers/md/md.c, function md_do_sync():

>                for_each_mddev(mddev2, tmp) {
>                        if (mddev2 == mddev)
>                                continue;
>                        if (!mddev->parallel_resync
>                        &&  mddev2->curr_resync
>                        &&  match_mddev_units(mddev, mddev2)) {
>                                DEFINE_WAIT(wq);
>                                if (mddev < mddev2 && mddev->curr_resync == 2) {
>                                        /* arbitrarily yield */
>                                        mddev->curr_resync = 1;
>                                        wake_up(&resync_wait);
>                                }
>                                if (mddev > mddev2 && mddev->curr_resync == 1)
>                                        /* no need to wait here, we can wait the next
>                                         * time 'round when curr_resync == 2
>                                         */
>                                        continue;
>                                /* We need to wait 'interruptible' so as not to

The type of mddev2 and mddev both are struct mddev *, so what's the
meaning of comparing these two variables?

Re: Pointer compare in md driver

[NeilBrown]

[-- Attachment #1: Type: text/plain, Size: 2358 bytes --]

On Tue, Oct 31 2017, wuzhouhui wrote:

> Hi,
>
> Sorry for disturbing, but I have consider this problem for several days.
> I have a question when reading md driver. Following is the code from
> linux/drivers/md/md.c, function md_do_sync():
>
>>                for_each_mddev(mddev2, tmp) {
>>                        if (mddev2 == mddev)
>>                                continue;
>>                        if (!mddev->parallel_resync
>>                        &&  mddev2->curr_resync
>>                        &&  match_mddev_units(mddev, mddev2)) {
>>                                DEFINE_WAIT(wq);
>>                                if (mddev < mddev2 && mddev->curr_resync == 2) {
>>                                        /* arbitrarily yield */
>>                                        mddev->curr_resync = 1;
>>                                        wake_up(&resync_wait);
>>                                }
>>                                if (mddev > mddev2 && mddev->curr_resync == 1)
>>                                        /* no need to wait here, we can wait the next
>>                                         * time 'round when curr_resync == 2
>>                                         */
>>                                        continue;
>>                                /* We need to wait 'interruptible' so as not to
>
> The type of mddev2 and mddev both are struct mddev *, so what's the
> meaning of comparing these two variables?

The ordering of the pointers provides an arbitrary ordering on different
md arrays.
If two arrays need to resync, and they share some devices (e.g. one uses
sda1, sdb1, sdc, and the other uses sda2, sdb2, sdc2, so both arrays use
the devices sda, sdb, and sdc), then the default policy is that only one
gets to resync at a time, the other one has to wait.
If one tries to start resyncing, and the other isn't resyncing, then it
can just go ahead and resync.  If one tries to start resyncing and the
other is already resyncing, then the new one needs to wait.
But what happens if both try to start at much the same time?
If an array is trying to start resync, and it notices that another array
that it shares devices with is also trying to start resync, then the one
with the larger value of the mddev pointer gets to go first.  The one
with the smaller value waits.

Hope that helps,
NeilBrown

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]