From: kernel test robot <lkp@intel.com>
To: "D. Wythe" <alibuda@linux.alibaba.com>,
kgraul@linux.ibm.com, wenjia@linux.ibm.com, jaka@linux.ibm.com,
ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org
Cc: oe-kbuild-all@lists.linux.dev, kuba@kernel.org,
davem@davemloft.net, netdev@vger.kernel.org,
linux-s390@vger.kernel.org, linux-rdma@vger.kernel.org,
bpf@vger.kernel.org
Subject: Re: [PATCH bpf-next v3 3/4] net/smc: add BPF injection on smc negotiation
Date: Tue, 28 Feb 2023 22:08:07 +0800 [thread overview]
Message-ID: <202302282100.x7qq7PGX-lkp@intel.com> (raw)
In-Reply-To: <1677576294-33411-4-git-send-email-alibuda@linux.alibaba.com>
Hi Wythe,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/D-Wythe/net-smc-move-smc_sock-related-structure-definition/20230228-173007
base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master
patch link: https://lore.kernel.org/r/1677576294-33411-4-git-send-email-alibuda%40linux.alibaba.com
patch subject: [PATCH bpf-next v3 3/4] net/smc: add BPF injection on smc negotiation
config: x86_64-randconfig-a015-20230227 (https://download.01.org/0day-ci/archive/20230228/202302282100.x7qq7PGX-lkp@intel.com/config)
compiler: gcc-11 (Debian 11.3.0-8) 11.3.0
reproduce (this is a W=1 build):
# https://github.com/intel-lab-lkp/linux/commit/aa482ab82f4bf9b99d490f8ba5d88e1491156ccf
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review D-Wythe/net-smc-move-smc_sock-related-structure-definition/20230228-173007
git checkout aa482ab82f4bf9b99d490f8ba5d88e1491156ccf
# save the config file
mkdir build_dir && cp config build_dir/.config
make W=1 O=build_dir ARCH=x86_64 olddefconfig
make W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash
If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <lkp@intel.com>
| Link: https://lore.kernel.org/oe-kbuild-all/202302282100.x7qq7PGX-lkp@intel.com/
All errors (new ones prefixed by >>):
ld: net/smc/af_smc.o: in function `smc_hs_congested':
>> net/smc/af_smc.c:169: undefined reference to `smc_sock_should_select_smc'
ld: net/smc/af_smc.o: in function `smc_release':
>> net/smc/af_smc.c:327: undefined reference to `smc_sock_perform_collecting_info'
ld: net/smc/af_smc.o: in function `smc_connect':
net/smc/af_smc.c:1637: undefined reference to `smc_sock_should_select_smc'
vim +169 net/smc/af_smc.c
156
157 static bool smc_hs_congested(const struct sock *sk)
158 {
159 const struct smc_sock *smc;
160
161 smc = smc_clcsock_user_data(sk);
162
163 if (!smc)
164 return true;
165
166 if (workqueue_congested(WORK_CPU_UNBOUND, smc_hs_wq))
167 return true;
168
> 169 if (!smc_sock_should_select_smc(smc))
170 return true;
171
172 return false;
173 }
174
175 static struct smc_hashinfo smc_v4_hashinfo = {
176 .lock = __RW_LOCK_UNLOCKED(smc_v4_hashinfo.lock),
177 };
178
179 static struct smc_hashinfo smc_v6_hashinfo = {
180 .lock = __RW_LOCK_UNLOCKED(smc_v6_hashinfo.lock),
181 };
182
183 int smc_hash_sk(struct sock *sk)
184 {
185 struct smc_hashinfo *h = sk->sk_prot->h.smc_hash;
186 struct hlist_head *head;
187
188 head = &h->ht;
189
190 write_lock_bh(&h->lock);
191 sk_add_node(sk, head);
192 write_unlock_bh(&h->lock);
193 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
194
195 return 0;
196 }
197 EXPORT_SYMBOL_GPL(smc_hash_sk);
198
199 void smc_unhash_sk(struct sock *sk)
200 {
201 struct smc_hashinfo *h = sk->sk_prot->h.smc_hash;
202
203 write_lock_bh(&h->lock);
204 if (sk_del_node_init(sk))
205 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
206 write_unlock_bh(&h->lock);
207 }
208 EXPORT_SYMBOL_GPL(smc_unhash_sk);
209
210 /* This will be called before user really release sock_lock. So do the
211 * work which we didn't do because of user hold the sock_lock in the
212 * BH context
213 */
214 static void smc_release_cb(struct sock *sk)
215 {
216 struct smc_sock *smc = smc_sk(sk);
217
218 if (smc->conn.tx_in_release_sock) {
219 smc_tx_pending(&smc->conn);
220 smc->conn.tx_in_release_sock = false;
221 }
222 }
223
224 struct proto smc_proto = {
225 .name = "SMC",
226 .owner = THIS_MODULE,
227 .keepalive = smc_set_keepalive,
228 .hash = smc_hash_sk,
229 .unhash = smc_unhash_sk,
230 .release_cb = smc_release_cb,
231 .obj_size = sizeof(struct smc_sock),
232 .h.smc_hash = &smc_v4_hashinfo,
233 .slab_flags = SLAB_TYPESAFE_BY_RCU,
234 };
235 EXPORT_SYMBOL_GPL(smc_proto);
236
237 struct proto smc_proto6 = {
238 .name = "SMC6",
239 .owner = THIS_MODULE,
240 .keepalive = smc_set_keepalive,
241 .hash = smc_hash_sk,
242 .unhash = smc_unhash_sk,
243 .release_cb = smc_release_cb,
244 .obj_size = sizeof(struct smc_sock),
245 .h.smc_hash = &smc_v6_hashinfo,
246 .slab_flags = SLAB_TYPESAFE_BY_RCU,
247 };
248 EXPORT_SYMBOL_GPL(smc_proto6);
249
250 static void smc_fback_restore_callbacks(struct smc_sock *smc)
251 {
252 struct sock *clcsk = smc->clcsock->sk;
253
254 write_lock_bh(&clcsk->sk_callback_lock);
255 clcsk->sk_user_data = NULL;
256
257 smc_clcsock_restore_cb(&clcsk->sk_state_change, &smc->clcsk_state_change);
258 smc_clcsock_restore_cb(&clcsk->sk_data_ready, &smc->clcsk_data_ready);
259 smc_clcsock_restore_cb(&clcsk->sk_write_space, &smc->clcsk_write_space);
260 smc_clcsock_restore_cb(&clcsk->sk_error_report, &smc->clcsk_error_report);
261
262 write_unlock_bh(&clcsk->sk_callback_lock);
263 }
264
265 static void smc_restore_fallback_changes(struct smc_sock *smc)
266 {
267 if (smc->clcsock->file) { /* non-accepted sockets have no file yet */
268 smc->clcsock->file->private_data = smc->sk.sk_socket;
269 smc->clcsock->file = NULL;
270 smc_fback_restore_callbacks(smc);
271 }
272 }
273
274 static int __smc_release(struct smc_sock *smc)
275 {
276 struct sock *sk = &smc->sk;
277 int rc = 0;
278
279 if (!smc->use_fallback) {
280 rc = smc_close_active(smc);
281 sock_set_flag(sk, SOCK_DEAD);
282 sk->sk_shutdown |= SHUTDOWN_MASK;
283 } else {
284 if (sk->sk_state != SMC_CLOSED) {
285 if (sk->sk_state != SMC_LISTEN &&
286 sk->sk_state != SMC_INIT)
287 sock_put(sk); /* passive closing */
288 if (sk->sk_state == SMC_LISTEN) {
289 /* wake up clcsock accept */
290 rc = kernel_sock_shutdown(smc->clcsock,
291 SHUT_RDWR);
292 }
293 sk->sk_state = SMC_CLOSED;
294 sk->sk_state_change(sk);
295 }
296 smc_restore_fallback_changes(smc);
297 }
298
299 sk->sk_prot->unhash(sk);
300
301 if (sk->sk_state == SMC_CLOSED) {
302 if (smc->clcsock) {
303 release_sock(sk);
304 smc_clcsock_release(smc);
305 lock_sock(sk);
306 }
307 if (!smc->use_fallback)
308 smc_conn_free(&smc->conn);
309 }
310
311 return rc;
312 }
313
314 static int smc_release(struct socket *sock)
315 {
316 struct sock *sk = sock->sk;
317 struct smc_sock *smc;
318 int old_state, rc = 0;
319
320 if (!sk)
321 goto out;
322
323 sock_hold(sk); /* sock_put below */
324 smc = smc_sk(sk);
325
326 /* trigger info gathering if needed.*/
> 327 smc_sock_perform_collecting_info(sk, SMC_SOCK_CLOSED_TIMING);
328
329 old_state = sk->sk_state;
330
331 /* cleanup for a dangling non-blocking connect */
332 if (smc->connect_nonblock && old_state == SMC_INIT)
333 tcp_abort(smc->clcsock->sk, ECONNABORTED);
334
335 if (cancel_work_sync(&smc->connect_work))
336 sock_put(&smc->sk); /* sock_hold in smc_connect for passive closing */
337
338 if (sk->sk_state == SMC_LISTEN)
339 /* smc_close_non_accepted() is called and acquires
340 * sock lock for child sockets again
341 */
342 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
343 else
344 lock_sock(sk);
345
346 if (old_state == SMC_INIT && sk->sk_state == SMC_ACTIVE &&
347 !smc->use_fallback)
348 smc_close_active_abort(smc);
349
350 rc = __smc_release(smc);
351
352 /* detach socket */
353 sock_orphan(sk);
354 sock->sk = NULL;
355 release_sock(sk);
356
357 sock_put(sk); /* sock_hold above */
358 sock_put(sk); /* final sock_put */
359 out:
360 return rc;
361 }
362
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests
next prev parent reply other threads:[~2023-02-28 14:08 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-02-28 9:24 [PATCH bpf-next v3 0/4] net/smc: Introduce BPF injection capability D. Wythe
2023-02-28 9:24 ` [PATCH bpf-next v3 1/4] net/smc: move smc_sock related structure definition D. Wythe
2023-02-28 9:24 ` [PATCH bpf-next v3 2/4] bpf: add SMC support in BPF struct_ops D. Wythe
2023-02-28 9:24 ` [PATCH bpf-next v3 3/4] net/smc: add BPF injection on smc negotiation D. Wythe
2023-02-28 14:08 ` kernel test robot [this message]
2023-02-28 15:54 ` D. Wythe
2023-02-28 16:08 ` D. Wythe
2023-02-28 9:24 ` [PATCH bpf-next v3 4/4] bpf/selftests: add selftest for SMC bpf capability D. Wythe
2023-02-28 23:00 ` [PATCH bpf-next v3 0/4] net/smc: Introduce BPF injection capability Jakub Kicinski
2023-03-01 2:40 ` D. Wythe
2023-03-01 2:41 ` Tony Lu
2023-03-01 3:24 ` Jakub Kicinski
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=202302282100.x7qq7PGX-lkp@intel.com \
--to=lkp@intel.com \
--cc=alibuda@linux.alibaba.com \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=davem@davemloft.net \
--cc=jaka@linux.ibm.com \
--cc=kgraul@linux.ibm.com \
--cc=kuba@kernel.org \
--cc=linux-rdma@vger.kernel.org \
--cc=linux-s390@vger.kernel.org \
--cc=netdev@vger.kernel.org \
--cc=oe-kbuild-all@lists.linux.dev \
--cc=wenjia@linux.ibm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.