| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Tue, 28 Feb 2023 23:54:05 +0800
From: "D. Wythe" <alibuda@...ux.alibaba.com>
To: kernel test robot <lkp@...el.com>, kgraul@...ux.ibm.com,
wenjia@...ux.ibm.com, jaka@...ux.ibm.com, ast@...nel.org,
daniel@...earbox.net, andrii@...nel.org
Cc: oe-kbuild-all@...ts.linux.dev, kuba@...nel.org,
davem@...emloft.net, netdev@...r.kernel.org,
linux-s390@...r.kernel.org, linux-rdma@...r.kernel.org,
bpf@...r.kernel.org
Subject: Re: [PATCH bpf-next v3 3/4] net/smc: add BPF injection on smc
negotiation
Hi robot,
It's seems impossible. I have compiled and tested this patch locally for many times.
Maybe you compiled this patch separately. However, this patch depends on the previous one.
Thanks
D. Wythe
On 2/28/23 10:08 PM, kernel test robot wrote:
> 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@...el.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
>
Powered by blists - more mailing lists