io_uring/poll.c:480:43: sparse: sparse: incorrect type in initializer (different base types)

[kernel test robot <lkp@intel.com>]

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head:   af3e9579ecfbe1796334bb25a2f0a6437983673a
commit: b9ba8a4463cd78d0aee520c4bf2569820ac29929 io_uring: add support for level triggered poll
date:   13 days ago
config: alpha-randconfig-s042-20220804 (https://download.01.org/0day-ci/archive/20220807/202208070511.4yxpxeFc-lkp@intel.com/config)
compiler: alpha-linux-gcc (GCC) 12.1.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # apt-get install sparse
        # sparse version: v0.6.4-39-gce1a6720-dirty
        # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b9ba8a4463cd78d0aee520c4bf2569820ac29929
        git remote add linus https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
        git fetch --no-tags linus master
        git checkout b9ba8a4463cd78d0aee520c4bf2569820ac29929
        # save the config file
        mkdir build_dir && cp config build_dir/.config
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' O=build_dir ARCH=alpha SHELL=/bin/bash

If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp@intel.com>

sparse warnings: (new ones prefixed by >>)
   io_uring/poll.c:165:38: sparse: sparse: incorrect type in assignment (different base types) @@     expected signed int [usertype] res @@     got restricted __poll_t @@
   io_uring/poll.c:165:38: sparse:     expected signed int [usertype] res
   io_uring/poll.c:165:38: sparse:     got restricted __poll_t
   io_uring/poll.c:176:56: sparse: sparse: restricted __poll_t degrades to integer
   io_uring/poll.c:175:66: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected restricted __poll_t [usertype] val @@     got unsigned int @@
   io_uring/poll.c:175:66: sparse:     expected restricted __poll_t [usertype] val
   io_uring/poll.c:175:66: sparse:     got unsigned int
   io_uring/poll.c:175:52: sparse: sparse: incorrect type in initializer (different base types) @@     expected restricted __poll_t [usertype] mask @@     got unsigned short @@
   io_uring/poll.c:175:52: sparse:     expected restricted __poll_t [usertype] mask
   io_uring/poll.c:175:52: sparse:     got unsigned short
   io_uring/poll.c:181:50: sparse: sparse: incorrect type in argument 3 (different base types) @@     expected signed int [usertype] res @@     got restricted __poll_t [usertype] mask @@
   io_uring/poll.c:181:50: sparse:     expected signed int [usertype] res
   io_uring/poll.c:181:50: sparse:     got restricted __poll_t [usertype] mask
   io_uring/poll.c:216:63: sparse: sparse: restricted __poll_t degrades to integer
   io_uring/poll.c:216:57: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected restricted __poll_t [usertype] val @@     got unsigned int @@
   io_uring/poll.c:216:57: sparse:     expected restricted __poll_t [usertype] val
   io_uring/poll.c:216:57: sparse:     got unsigned int
   io_uring/poll.c:334:40: sparse: sparse: incorrect type in argument 2 (different base types) @@     expected int mask @@     got restricted __poll_t [usertype] mask @@
   io_uring/poll.c:334:40: sparse:     expected int mask
   io_uring/poll.c:334:40: sparse:     got restricted __poll_t [usertype] mask
   io_uring/poll.c:430:24: sparse: sparse: incorrect type in return expression (different base types) @@     expected int @@     got restricted __poll_t [assigned] [usertype] mask @@
   io_uring/poll.c:430:24: sparse:     expected int
   io_uring/poll.c:430:24: sparse:     got restricted __poll_t [assigned] [usertype] mask
   io_uring/poll.c:451:40: sparse: sparse: incorrect type in argument 2 (different base types) @@     expected int mask @@     got restricted __poll_t [assigned] [usertype] mask @@
   io_uring/poll.c:451:40: sparse:     expected int mask
   io_uring/poll.c:451:40: sparse:     got restricted __poll_t [assigned] [usertype] mask
   io_uring/poll.c:480:45: sparse: sparse: restricted __poll_t degrades to integer
>> io_uring/poll.c:480:43: sparse: sparse: incorrect type in initializer (different base types) @@     expected restricted __poll_t [usertype] mask @@     got unsigned int @@
   io_uring/poll.c:480:43: sparse:     expected restricted __poll_t [usertype] mask
   io_uring/poll.c:480:43: sparse:     got unsigned int
   io_uring/poll.c:528:33: sparse: sparse: incorrect type in argument 5 (different base types) @@     expected int mask @@     got restricted __poll_t [assigned] [usertype] mask @@
   io_uring/poll.c:528:33: sparse:     expected int mask
   io_uring/poll.c:528:33: sparse:     got restricted __poll_t [assigned] [usertype] mask
   io_uring/poll.c:528:50: sparse: sparse: incorrect type in argument 6 (different base types) @@     expected int events @@     got restricted __poll_t [usertype] events @@
   io_uring/poll.c:528:50: sparse:     expected int events
   io_uring/poll.c:528:50: sparse:     got restricted __poll_t [usertype] events
   io_uring/poll.c:642:24: sparse: sparse: invalid assignment: |=
   io_uring/poll.c:642:24: sparse:    left side has type unsigned int
   io_uring/poll.c:642:24: sparse:    right side has type restricted __poll_t
   io_uring/poll.c:644:24: sparse: sparse: invalid assignment: |=
   io_uring/poll.c:644:24: sparse:    left side has type unsigned int
   io_uring/poll.c:644:24: sparse:    right side has type restricted __poll_t
   io_uring/poll.c:646:55: sparse: sparse: restricted __poll_t degrades to integer
   io_uring/poll.c:645:29: sparse: sparse: restricted __poll_t degrades to integer
   io_uring/poll.c:645:38: sparse: sparse: incorrect type in return expression (different base types) @@     expected restricted __poll_t @@     got unsigned int @@
   io_uring/poll.c:645:38: sparse:     expected restricted __poll_t
   io_uring/poll.c:645:38: sparse:     got unsigned int
   io_uring/poll.c:741:38: sparse: sparse: invalid assignment: &=
   io_uring/poll.c:741:38: sparse:    left side has type restricted __poll_t
   io_uring/poll.c:741:38: sparse:    right side has type int
   io_uring/poll.c:742:52: sparse: sparse: restricted __poll_t degrades to integer
   io_uring/poll.c:742:38: sparse: sparse: invalid assignment: |=
   io_uring/poll.c:742:38: sparse:    left side has type restricted __poll_t
   io_uring/poll.c:742:38: sparse:    right side has type unsigned int
   io_uring/poll.c: note: in included file:
   io_uring/io_uring_types.h:92:37: sparse: sparse: array of flexible structures

vim +480 io_uring/poll.c

   288	
   289	static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
   290				void *key)
   291	{
   292		struct io_kiocb *req = wqe_to_req(wait);
   293		struct io_poll *poll = container_of(wait, struct io_poll, wait);
   294		__poll_t mask = key_to_poll(key);
   295	
   296		if (unlikely(mask & POLLFREE)) {
   297			io_poll_mark_cancelled(req);
   298			/* we have to kick tw in case it's not already */
   299			io_poll_execute(req, 0, poll->events);
   300	
   301			/*
   302			 * If the waitqueue is being freed early but someone is already
   303			 * holds ownership over it, we have to tear down the request as
   304			 * best we can. That means immediately removing the request from
   305			 * its waitqueue and preventing all further accesses to the
   306			 * waitqueue via the request.
   307			 */
   308			list_del_init(&poll->wait.entry);
   309	
   310			/*
   311			 * Careful: this *must* be the last step, since as soon
   312			 * as req->head is NULL'ed out, the request can be
   313			 * completed and freed, since aio_poll_complete_work()
   314			 * will no longer need to take the waitqueue lock.
   315			 */
   316			smp_store_release(&poll->head, NULL);
   317			return 1;
   318		}
   319	
   320		/* for instances that support it check for an event match first */
   321		if (mask && !(mask & (poll->events & ~IO_ASYNC_POLL_COMMON)))
   322			return 0;
   323	
   324		if (io_poll_get_ownership(req)) {
   325			/* optional, saves extra locking for removal in tw handler */
   326			if (mask && poll->events & EPOLLONESHOT) {
   327				list_del_init(&poll->wait.entry);
   328				poll->head = NULL;
   329				if (wqe_is_double(wait))
   330					req->flags &= ~REQ_F_DOUBLE_POLL;
   331				else
   332					req->flags &= ~REQ_F_SINGLE_POLL;
   333			}
 > 334			__io_poll_execute(req, mask, poll->events);
   335		}
   336		return 1;
   337	}
   338	
   339	static void __io_queue_proc(struct io_poll *poll, struct io_poll_table *pt,
   340				    struct wait_queue_head *head,
   341				    struct io_poll **poll_ptr)
   342	{
   343		struct io_kiocb *req = pt->req;
   344		unsigned long wqe_private = (unsigned long) req;
   345	
   346		/*
   347		 * The file being polled uses multiple waitqueues for poll handling
   348		 * (e.g. one for read, one for write). Setup a separate io_poll
   349		 * if this happens.
   350		 */
   351		if (unlikely(pt->nr_entries)) {
   352			struct io_poll *first = poll;
   353	
   354			/* double add on the same waitqueue head, ignore */
   355			if (first->head == head)
   356				return;
   357			/* already have a 2nd entry, fail a third attempt */
   358			if (*poll_ptr) {
   359				if ((*poll_ptr)->head == head)
   360					return;
   361				pt->error = -EINVAL;
   362				return;
   363			}
   364	
   365			poll = kmalloc(sizeof(*poll), GFP_ATOMIC);
   366			if (!poll) {
   367				pt->error = -ENOMEM;
   368				return;
   369			}
   370			/* mark as double wq entry */
   371			wqe_private |= 1;
   372			req->flags |= REQ_F_DOUBLE_POLL;
   373			io_init_poll_iocb(poll, first->events, first->wait.func);
   374			*poll_ptr = poll;
   375			if (req->opcode == IORING_OP_POLL_ADD)
   376				req->flags |= REQ_F_ASYNC_DATA;
   377		}
   378	
   379		req->flags |= REQ_F_SINGLE_POLL;
   380		pt->nr_entries++;
   381		poll->head = head;
   382		poll->wait.private = (void *) wqe_private;
   383	
   384		if (poll->events & EPOLLEXCLUSIVE)
   385			add_wait_queue_exclusive(head, &poll->wait);
   386		else
   387			add_wait_queue(head, &poll->wait);
   388	}
   389	
   390	static void io_poll_queue_proc(struct file *file, struct wait_queue_head *head,
   391				       struct poll_table_struct *p)
   392	{
   393		struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);
   394		struct io_poll *poll = io_kiocb_to_cmd(pt->req);
   395	
   396		__io_queue_proc(poll, pt, head,
   397				(struct io_poll **) &pt->req->async_data);
   398	}
   399	
   400	static int __io_arm_poll_handler(struct io_kiocb *req,
   401					 struct io_poll *poll,
   402					 struct io_poll_table *ipt, __poll_t mask)
   403	{
   404		struct io_ring_ctx *ctx = req->ctx;
   405		int v;
   406	
   407		INIT_HLIST_NODE(&req->hash_node);
   408		req->work.cancel_seq = atomic_read(&ctx->cancel_seq);
   409		io_init_poll_iocb(poll, mask, io_poll_wake);
   410		poll->file = req->file;
   411	
   412		req->apoll_events = poll->events;
   413	
   414		ipt->pt._key = mask;
   415		ipt->req = req;
   416		ipt->error = 0;
   417		ipt->nr_entries = 0;
   418	
   419		/*
   420		 * Take the ownership to delay any tw execution up until we're done
   421		 * with poll arming. see io_poll_get_ownership().
   422		 */
   423		atomic_set(&req->poll_refs, 1);
   424		mask = vfs_poll(req->file, &ipt->pt) & poll->events;
   425	
   426		if (mask &&
   427		   ((poll->events & (EPOLLET|EPOLLONESHOT)) == (EPOLLET|EPOLLONESHOT))) {
   428			io_poll_remove_entries(req);
   429			/* no one else has access to the req, forget about the ref */
   430			return mask;
   431		}
   432	
   433		if (!mask && unlikely(ipt->error || !ipt->nr_entries)) {
   434			io_poll_remove_entries(req);
   435			if (!ipt->error)
   436				ipt->error = -EINVAL;
   437			return 0;
   438		}
   439	
   440		spin_lock(&ctx->completion_lock);
   441		io_poll_req_insert(req);
   442		spin_unlock(&ctx->completion_lock);
   443	
   444		if (mask && (poll->events & EPOLLET)) {
   445			/* can't multishot if failed, just queue the event we've got */
   446			if (unlikely(ipt->error || !ipt->nr_entries)) {
   447				poll->events |= EPOLLONESHOT;
   448				req->apoll_events |= EPOLLONESHOT;
   449				ipt->error = 0;
   450			}
   451			__io_poll_execute(req, mask, poll->events);
   452			return 0;
   453		}
   454	
   455		/*
   456		 * Release ownership. If someone tried to queue a tw while it was
   457		 * locked, kick it off for them.
   458		 */
   459		v = atomic_dec_return(&req->poll_refs);
   460		if (unlikely(v & IO_POLL_REF_MASK))
   461			__io_poll_execute(req, 0, poll->events);
   462		return 0;
   463	}
   464	
   465	static void io_async_queue_proc(struct file *file, struct wait_queue_head *head,
   466				       struct poll_table_struct *p)
   467	{
   468		struct io_poll_table *pt = container_of(p, struct io_poll_table, pt);
   469		struct async_poll *apoll = pt->req->apoll;
   470	
   471		__io_queue_proc(&apoll->poll, pt, head, &apoll->double_poll);
   472	}
   473	
   474	int io_arm_poll_handler(struct io_kiocb *req, unsigned issue_flags)
   475	{
   476		const struct io_op_def *def = &io_op_defs[req->opcode];
   477		struct io_ring_ctx *ctx = req->ctx;
   478		struct async_poll *apoll;
   479		struct io_poll_table ipt;
 > 480		__poll_t mask = POLLPRI | POLLERR | EPOLLET;
   481		int ret;
   482	
   483		if (!def->pollin && !def->pollout)
   484			return IO_APOLL_ABORTED;
   485		if (!file_can_poll(req->file))
   486			return IO_APOLL_ABORTED;
   487		if ((req->flags & (REQ_F_POLLED|REQ_F_PARTIAL_IO)) == REQ_F_POLLED)
   488			return IO_APOLL_ABORTED;
   489		if (!(req->flags & REQ_F_APOLL_MULTISHOT))
   490			mask |= EPOLLONESHOT;
   491	
   492		if (def->pollin) {
   493			mask |= EPOLLIN | EPOLLRDNORM;
   494	
   495			/* If reading from MSG_ERRQUEUE using recvmsg, ignore POLLIN */
   496			if (req->flags & REQ_F_CLEAR_POLLIN)
   497				mask &= ~EPOLLIN;
   498		} else {
   499			mask |= EPOLLOUT | EPOLLWRNORM;
   500		}
   501		if (def->poll_exclusive)
   502			mask |= EPOLLEXCLUSIVE;
   503		if (req->flags & REQ_F_POLLED) {
   504			apoll = req->apoll;
   505			kfree(apoll->double_poll);
   506		} else if (!(issue_flags & IO_URING_F_UNLOCKED) &&
   507			   !list_empty(&ctx->apoll_cache)) {
   508			apoll = list_first_entry(&ctx->apoll_cache, struct async_poll,
   509							poll.wait.entry);
   510			list_del_init(&apoll->poll.wait.entry);
   511		} else {
   512			apoll = kmalloc(sizeof(*apoll), GFP_ATOMIC);
   513			if (unlikely(!apoll))
   514				return IO_APOLL_ABORTED;
   515		}
   516		apoll->double_poll = NULL;
   517		req->apoll = apoll;
   518		req->flags |= REQ_F_POLLED;
   519		ipt.pt._qproc = io_async_queue_proc;
   520	
   521		io_kbuf_recycle(req, issue_flags);
   522	
   523		ret = __io_arm_poll_handler(req, &apoll->poll, &ipt, mask);
   524		if (ret || ipt.error)
   525			return ret ? IO_APOLL_READY : IO_APOLL_ABORTED;
   526	
   527		trace_io_uring_poll_arm(ctx, req, req->cqe.user_data, req->opcode,
   528					mask, apoll->poll.events);
   529		return IO_APOLL_OK;
   530	}
   531	

-- 
0-DAY CI Kernel Test Service
https://01.org/lkp