Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18;
MIME-Version: 1.0
References: <CAAo+4rXNLdgvAiT2-B8cWtLNPnWoGo9RWMW=8SPchzRgxJ4BhA@mail.gmail.com>
In-Reply-To: <CAAo+4rXNLdgvAiT2-B8cWtLNPnWoGo9RWMW=8SPchzRgxJ4BhA@mail.gmail.com>
From:   =?UTF-8?B?5Y+25r6E6ZSL?= <dg573847474@gmail.com>
Date:   Sat, 28 Aug 2021 16:06:33 +0800
Message-ID: <CAAo+4rVJg--eTqsMPDHtpD2dCnivgWs0xc4eCty3eW05BTJRhw@mail.gmail.com>
Subject: Re: Possible deadlock errors in tools/perf/builtin-sched.c
To:     peterz@infradead.org, mingo@redhat.com, acme@kernel.org
Cc:     mark.rutland@arm.com, alexander.shishkin@linux.intel.com,
        jolsa@redhat.com, namhyung@kernel.org,
        linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org,
        CAI Yuandao <ycaibb@cse.ust.hk>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Precedence: bulk

Dear developers:

Thank you for your checking.

It seems there are two deadlock errors on the
locksched->work_done_wait_mutexandsched->start_work_mutex.

They are triggered due to one thread(A) runs function run_one_test
locating in a loop and unreleasing the two locks in
thewait_for_tasksfunction, and another thread(B) runs function
thread_func acquiring the two locks.

Because the two locks are not properly released in thread A, there
will be a  deadlock problem if thread B acquires the two locks.

The related codes are below:

Thread A:

static void create_tasks(struct perf_sched *sched)
{
     ...;
    err =3D pthread_mutex_lock(&sched->start_work_mutex);
    ...;
    err =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
    ...;
}

static int perf_sched__replay(struct perf_sched *sched)
{
   ...;
     create_tasks(sched);
     printf("------------------------------------------------------------\n=
");
     for (i =3D 0; i < sched->replay_repeat; i++)
          run_one_test(sched);   // multiple reacquisition on the lock
sched->work_done_wait_mutex and sched->start_work_mutex

   return 0;
}

static void run_one_test(struct perf_sched *sched)
{
        ...;
      wait_for_tasks(sched);
        ...;
}

static void wait_for_tasks(struct perf_sched *sched)
{
      ...;
     pthread_mutex_unlock(&sched->work_done_wait_mutex);
      ...;
     ret =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
     ...;
     pthread_mutex_unlock(&sched->start_work_mutex);
     ...;

    ret =3D pthread_mutex_lock(&sched->start_work_mutex);
    ....;
}

Thread B:
static void *thread_func(void *ctx)
{
...;
ret =3D pthread_mutex_lock(&sched->start_work_mutex);
...;
ret =3D pthread_mutex_unlock(&sched->start_work_mutex);

...;

ret =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
...;
ret =3D pthread_mutex_unlock(&sched->work_done_wait_mutex);
..;

}

PS: The previous email fails to reach the maillist, so I send it again.

Thanks,

=E5=8F=B6=E6=BE=84=E9=94=8B <dg573847474@gmail.com> =E4=BA=8E2021=E5=B9=B48=
=E6=9C=8828=E6=97=A5=E5=91=A8=E5=85=AD =E4=B8=8B=E5=8D=883:57=E5=86=99=E9=
=81=93=EF=BC=9A
>
> Dear developers:
>
> Thank you for your checking.
>
> It seems there are two deadlock errors on the locksched->work_done_wait_m=
utexandsched->start_work_mutex.
>
> They are triggered due to one thread(A) runs function run_one_test locati=
ng in a loop and unreleasing the two locks in thewait_for_tasksfunction, an=
d another thread(B) runs function thread_func acquiring the two locks.
>
> Because the two locks are not properly released in thread A, there will b=
e a  deadlock problem if thread B acquires the two locks.
>
> The related codes are below:
>
> Thread A:
>
> static void create_tasks(struct perf_sched *sched)
> {
>      ...;
>   err =3D pthread_mutex_lock(&sched->start_work_mutex);
>     ...;
>  err =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
>        ...;
> }
> static int perf_sched__replay(struct perf_sched *sched)
> {
>    ...;
>
>         create_tasks(sched);
>      printf("------------------------------------------------------------=
\n");
>      for (i =3D 0; i < sched->replay_repeat; i++)
>           run_one_test(sched);   // multiple reacquisition on the lock sc=
hed->work_done_wait_mutex and sched->start_work_mutex
>
>    return 0;
> }
>
> static void run_one_test(struct perf_sched *sched)
> {
>  ...;
>       wait_for_tasks(sched);
>         ...;
> }
> static void wait_for_tasks(struct perf_sched *sched)
> {
>        ...;
>     pthread_mutex_unlock(&sched->work_done_wait_mutex);
>
>   ...;
>        ret =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
>      ...;
>   pthread_mutex_unlock(&sched->start_work_mutex);
>
>     ...;
>
>  ret =3D pthread_mutex_lock(&sched->start_work_mutex);
>    ....;
> }
>
> Thread B:
>
> static void *thread_func(void *ctx)
> {
>
> ...;
> ret =3D pthread_mutex_lock(&sched->start_work_mutex);
> ...;
> ret =3D pthread_mutex_unlock(&sched->start_work_mutex);
>
> ...;
>
> ret =3D pthread_mutex_lock(&sched->work_done_wait_mutex);
> ...;
> ret =3D pthread_mutex_unlock(&sched->work_done_wait_mutex);
> ..;
>
> }
>
>
> Thanks,