Re: [PATCH bpf-next v3 3/4] net/smc: add BPF injection on smc negotiation

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 




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@xxxxxxxxx/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@xxxxxxxxx>
| Link: https://lore.kernel.org/oe-kbuild-all/202302282100.x7qq7PGX-lkp@xxxxxxxxx/

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	




[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Index of Archives]     [Kernel Development]     [Kernel Newbies]     [IDE]     [Security]     [Git]     [Netfilter]     [Bugtraq]     [Yosemite Info]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Linux ATA RAID]     [Samba]     [Linux Media]     [Device Mapper]

  Powered by Linux