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;
Subject: Re: [peterz-queue:locking/core 41/43] kernel/locking/rwsem.c:1023:19:
 error: variable has incomplete type 'enum owner_state'
To:     kernel test robot <lkp@intel.com>
Cc:     llvm@lists.linux.dev, kbuild-all@lists.01.org,
        linux-kernel@vger.kernel.org, Peter Zijlstra <peterz@infradead.org>
References: <202110152145.nWCivoXy-lkp@intel.com>
From:   "Xu, Yanfei" <yanfei.xu@windriver.com>
Message-ID: <8c0f011a-db83-001e-3cce-326cb8228a75@windriver.com>
Date:   Sat, 16 Oct 2021 02:41:17 +0800
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101
 Thunderbird/68.10.0
In-Reply-To: <202110152145.nWCivoXy-lkp@intel.com>
Content-Type: text/plain; charset=windows-1252; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
MIME-Version: 1.0
X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1
X-MS-Exchange-AntiSpam-MessageData-0: =?Windows-1252?Q?H0HN4J9v7L3d/hnx383FekNGOk23HqZjmHMkVf06ci+IqZ7Egz7Mpg3m?=
 =?Windows-1252?Q?TuV/DNRKFEVCB+pBpiZOIy3908l0JM7oQA2rBcgweP5u+4RzE7wJcFWw?=
 =?Windows-1252?Q?gKv16I+IU4P+ktpV6mLF+wind8Ypm0eFgaJzpBfLBccXGvS+bERJuxEJ?=
 =?Windows-1252?Q?xJD72TSRg5BpauvSF0IFb2HoBlhCu9XHxkMqfSn9N3YjZZy3e3HoCe+E?=
 =?Windows-1252?Q?E+mQVBdqKbM50DvkFBAHpxIJaCZ2r31QOdqhqz0CEQPhh6k33o9VP0W3?=
 =?Windows-1252?Q?Xdz3hzbp9LjZbMiJ4SC20K+S+b/eYBefoU1fzsSb/b4G7S/swCkKax68?=
 =?Windows-1252?Q?jXPklj/DDOmsP9JeVahjVc545gJ4x6VSnAy/wP7OhAENZ3WVT08k6G7m?=
 =?Windows-1252?Q?1Ed800yTt27RBQ63DJxCbcoUKDgPLziFYTpFvOlG1nLu7NF8zL7ypjBz?=
 =?Windows-1252?Q?CnyxfBzJZqVtUaoZ8Koh1KeCeBglX5XHHw0uCkaRLzdDboGByMIlD5XS?=
 =?Windows-1252?Q?LTxfPZlurhvkuei1Yoxzz06Oh4+JR647/Rws7cEMmGoY/VDfyAysqKRh?=
 =?Windows-1252?Q?qh9gtNnlxpSnHC34R6+SB/co7R7aHsQKrkTsyIs5oeAYGrpkJV9/WJUj?=
 =?Windows-1252?Q?/ZHFtsfKUp44BlhV7dx1+XDzzlYwPLunUwFnSUVfuFzewRK1/xp9ehoS?=
 =?Windows-1252?Q?CPtnDsHxtE0sLl2qOw6W4Dpw9akckAWk3Km5RcFVD1O36EZdTuBpkk4R?=
 =?Windows-1252?Q?FVSpBTyGHreAYcw1zsrzZtJ9fbsqsYEZpiKgmuTQfiTguS+BmMwwiecZ?=
 =?Windows-1252?Q?Gspq/0GeyWPTuj/omGxmsuv7KKF/QpOOHVLG5GChmCmwkqLaCKcrWY8L?=
 =?Windows-1252?Q?BjKMITSmVku6LLpXO6z+svdS4424qGymVKOZOxhB0ZD+8S66w49EjyPG?=
 =?Windows-1252?Q?mSRTpKdsjymDueTA4MW7B+QXYZogVy1DU4DfoFUrO6bdi1gDRJ2jX3mW?=
 =?Windows-1252?Q?jDJ0+nm2WfebDt9ZOrrROvdVSXqxiZbNK949IlgkpmLzFf7fid0IrWFh?=
 =?Windows-1252?Q?DYpuCL0nqwvyZAWW0qEpRCmPn0gmq2LTDnU/fUyFGsiIZXbqsMnMuqDF?=
 =?Windows-1252?Q?ZBBU/LOkUaNSo+66r1VjhfGr90PznAh8nYmsCjT7C4VkBFLPAnz4TaXr?=
 =?Windows-1252?Q?uX5fEG6bL0JdbI8GZx5hS0s366dVlNFzymkOxX8DrNtezbgo2tJTz5Wq?=
 =?Windows-1252?Q?byxPR04iyvCe/y62wT/NSF520oWcLO8UXhqk2SAipqAa9FscT8hE1evj?=
 =?Windows-1252?Q?LK81bjXgbSmuJeIHWOE1ziLYhKLWatui2y58mzB4JzcwG51KCYQX2ayT?=
 =?Windows-1252?Q?+rxHVCworXv8Pb1Y7Fx0rEA9jL4yGGM0rgiTfouWd8VnaMHW2CUScLbc?=
X-OriginatorOrg: windriver.com
X-MS-Exchange-CrossTenant-Network-Message-Id: a3c51a3a-a73d-42a8-ff3f-08d9900b63dc
X-MS-Exchange-CrossTenant-AuthSource: DM8PR11MB5734.namprd11.prod.outlook.com
X-MS-Exchange-CrossTenant-AuthAs: Internal
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 15 Oct 2021 18:41:24.7229
 (UTC)
X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted
X-MS-Exchange-CrossTenant-Id: 8ddb2873-a1ad-4a18-ae4e-4644631433be
X-MS-Exchange-CrossTenant-MailboxType: HOSTED
X-MS-Exchange-CrossTenant-UserPrincipalName: I4cT1fUdyv/3QSXkFNcNfXiYHw4X10ZtIG9qMuffgLoiZP+Beuc+zCV/RCVIjnCFj+F2DPv+7GR+LhLpVrfvHQ==
X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR11MB2602
X-Proofpoint-ORIG-GUID: 6LyB1HL3cAAWb9X2w7lBOYugKUnxt-Hl
X-Proofpoint-GUID: 6LyB1HL3cAAWb9X2w7lBOYugKUnxt-Hl
X-Proofpoint-Virus-Version: vendor=baseguard
 engine=ICAP:2.0.182.1,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.0.607.475
 definitions=2021-10-15_06,2021-10-14_02,2020-04-07_01
X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 adultscore=0 mlxscore=0
 bulkscore=0 phishscore=0 spamscore=0 lowpriorityscore=0 mlxlogscore=999
 priorityscore=1501 suspectscore=0 impostorscore=0 clxscore=1011
 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1
 engine=8.12.0-2109230001 definitions=main-2110150114
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org


On 10/15/21 9:51 PM, kernel test robot wrote:
> [Please note: This e-mail is from an EXTERNAL e-mail address]
> 
> tree:   https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git locking/core
> head:   44e63f63c47dfb202eb25cdd97d04ec7e47f51d8
> commit: b08614038dba3f6982e1e7701f23784bb0aedba6 [41/43] locking/rwsem: disable preemption for spinning region
> config: hexagon-randconfig-r041-20211014 (attached as .config)
> compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project acb3b187c4c88650a6a717a1bcb234d27d0d7f54)
> reproduce (this is a W=1 build):
>          wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>          chmod +x ~/bin/make.cross
>          # https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git/commit/?id=b08614038dba3f6982e1e7701f23784bb0aedba6
>          git remote add peterz-queue https://git.kernel.org/pub/scm/linux/kernel/git/peterz/queue.git
>          git fetch --no-tags peterz-queue locking/core
>          git checkout b08614038dba3f6982e1e7701f23784bb0aedba6
>          # save the attached .config to linux build tree
>          mkdir build_dir
>          COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=hexagon SHELL=/bin/bash kernel/locking/
> 
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
> 
> All errors (new ones prefixed by >>):
> 
>>> kernel/locking/rwsem.c:1023:19: error: variable has incomplete type 'enum owner_state'
>             enum owner_state owner_state;
>                              ^
>     kernel/locking/rwsem.c:1023:7: note: forward declaration of 'enum owner_state'
>             enum owner_state owner_state;
>                  ^
>     1 error generated.
> 


Hi Peter,

I send a patch named ("locking/rwsem: Introduce 
__rwsem_spin_on_owner()") for fixing this.

Thanks,
Yanfei

> 
> vim +1023 kernel/locking/rwsem.c
> 
>    1012
>    1013  /*
>    1014   * Wait until we successfully acquire the write lock
>    1015   */
>    1016  static struct rw_semaphore *
>    1017  rwsem_down_write_slowpath(struct rw_semaphore *sem, int state)
>    1018  {
>    1019          long count;
>    1020          enum writer_wait_state wstate;
>    1021          struct rwsem_waiter waiter;
>    1022          struct rw_semaphore *ret = sem;
>> 1023          enum owner_state owner_state;
>    1024          DEFINE_WAKE_Q(wake_q);
>    1025
>    1026          /* do optimistic spinning and steal lock if possible */
>    1027          if (rwsem_can_spin_on_owner(sem) && rwsem_optimistic_spin(sem)) {
>    1028                  /* rwsem_optimistic_spin() implies ACQUIRE on success */
>    1029                  return sem;
>    1030          }
>    1031
>    1032          /*
>    1033           * Optimistic spinning failed, proceed to the slowpath
>    1034           * and block until we can acquire the sem.
>    1035           */
>    1036          waiter.task = current;
>    1037          waiter.type = RWSEM_WAITING_FOR_WRITE;
>    1038          waiter.timeout = jiffies + RWSEM_WAIT_TIMEOUT;
>    1039
>    1040          raw_spin_lock_irq(&sem->wait_lock);
>    1041
>    1042          /* account for this before adding a new element to the list */
>    1043          wstate = list_empty(&sem->wait_list) ? WRITER_FIRST : WRITER_NOT_FIRST;
>    1044
>    1045          list_add_tail(&waiter.list, &sem->wait_list);
>    1046
>    1047          /* we're now waiting on the lock */
>    1048          if (wstate == WRITER_NOT_FIRST) {
>    1049                  count = atomic_long_read(&sem->count);
>    1050
>    1051                  /*
>    1052                   * If there were already threads queued before us and:
>    1053                   *  1) there are no active locks, wake the front
>    1054                   *     queued process(es) as the handoff bit might be set.
>    1055                   *  2) there are no active writers and some readers, the lock
>    1056                   *     must be read owned; so we try to wake any read lock
>    1057                   *     waiters that were queued ahead of us.
>    1058                   */
>    1059                  if (count & RWSEM_WRITER_MASK)
>    1060                          goto wait;
>    1061
>    1062                  rwsem_mark_wake(sem, (count & RWSEM_READER_MASK)
>    1063                                          ? RWSEM_WAKE_READERS
>    1064                                          : RWSEM_WAKE_ANY, &wake_q);
>    1065
>    1066                  if (!wake_q_empty(&wake_q)) {
>    1067                          /*
>    1068                           * We want to minimize wait_lock hold time especially
>    1069                           * when a large number of readers are to be woken up.
>    1070                           */
>    1071                          raw_spin_unlock_irq(&sem->wait_lock);
>    1072                          wake_up_q(&wake_q);
>    1073                          wake_q_init(&wake_q);   /* Used again, reinit */
>    1074                          raw_spin_lock_irq(&sem->wait_lock);
>    1075                  }
>    1076          } else {
>    1077                  atomic_long_or(RWSEM_FLAG_WAITERS, &sem->count);
>    1078          }
>    1079
>    1080  wait:
>    1081          /* wait until we successfully acquire the lock */
>    1082          set_current_state(state);
>    1083          for (;;) {
>    1084                  if (rwsem_try_write_lock(sem, wstate)) {
>    1085                          /* rwsem_try_write_lock() implies ACQUIRE on success */
>    1086                          break;
>    1087                  }
>    1088
>    1089                  raw_spin_unlock_irq(&sem->wait_lock);
>    1090
>    1091                  /*
>    1092                   * After setting the handoff bit and failing to acquire
>    1093                   * the lock, attempt to spin on owner to accelerate lock
>    1094                   * transfer. If the previous owner is a on-cpu writer and it
>    1095                   * has just released the lock, OWNER_NULL will be returned.
>    1096                   * In this case, we attempt to acquire the lock again
>    1097                   * without sleeping.
>    1098                   */
>    1099                  if (wstate == WRITER_HANDOFF) {
>    1100                          preempt_disable();
>    1101                          owner_state = rwsem_spin_on_owner(sem);
>    1102                          preempt_enable();
>    1103                          if (owner_state == OWNER_NULL)
>    1104                                  goto trylock_again;
>    1105                  }
>    1106
>    1107                  /* Block until there are no active lockers. */
>    1108                  for (;;) {
>    1109                          if (signal_pending_state(state, current))
>    1110                                  goto out_nolock;
>    1111
>    1112                          schedule();
>    1113                          lockevent_inc(rwsem_sleep_writer);
>    1114                          set_current_state(state);
>    1115                          /*
>    1116                           * If HANDOFF bit is set, unconditionally do
>    1117                           * a trylock.
>    1118                           */
>    1119                          if (wstate == WRITER_HANDOFF)
>    1120                                  break;
>    1121
>    1122                          if ((wstate == WRITER_NOT_FIRST) &&
>    1123                              (rwsem_first_waiter(sem) == &waiter))
>    1124                                  wstate = WRITER_FIRST;
>    1125
>    1126                          count = atomic_long_read(&sem->count);
>    1127                          if (!(count & RWSEM_LOCK_MASK))
>    1128                                  break;
>    1129
>    1130                          /*
>    1131                           * The setting of the handoff bit is deferred
>    1132                           * until rwsem_try_write_lock() is called.
>    1133                           */
>    1134                          if ((wstate == WRITER_FIRST) && (rt_task(current) ||
>    1135                              time_after(jiffies, waiter.timeout))) {
>    1136                                  wstate = WRITER_HANDOFF;
>    1137                                  lockevent_inc(rwsem_wlock_handoff);
>    1138                                  break;
>    1139                          }
>    1140                  }
>    1141  trylock_again:
>    1142                  raw_spin_lock_irq(&sem->wait_lock);
>    1143          }
>    1144          __set_current_state(TASK_RUNNING);
>    1145          list_del(&waiter.list);
>    1146          raw_spin_unlock_irq(&sem->wait_lock);
>    1147          lockevent_inc(rwsem_wlock);
>    1148
>    1149          return ret;
>    1150
>    1151  out_nolock:
>    1152          __set_current_state(TASK_RUNNING);
>    1153          raw_spin_lock_irq(&sem->wait_lock);
>    1154          list_del(&waiter.list);
>    1155
>    1156          if (unlikely(wstate == WRITER_HANDOFF))
>    1157                  atomic_long_add(-RWSEM_FLAG_HANDOFF,  &sem->count);
>    1158
>    1159          if (list_empty(&sem->wait_list))
>    1160                  atomic_long_andnot(RWSEM_FLAG_WAITERS, &sem->count);
>    1161          else
>    1162                  rwsem_mark_wake(sem, RWSEM_WAKE_ANY, &wake_q);
>    1163          raw_spin_unlock_irq(&sem->wait_lock);
>    1164          wake_up_q(&wake_q);
>    1165          lockevent_inc(rwsem_wlock_fail);
>    1166
>    1167          return ERR_PTR(-EINTR);
>    1168  }
>    1169
> 
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
>