Treewide: Stop corrupting socket's task_frag

Since moving to memalloc_nofs_save/restore, SUNRPC has stopped setting the
GFP_NOIO flag on sk_allocation which the networking system uses to decide
when it is safe to use current->task_frag. The results of this are
unexpected corruption in task_frag when SUNRPC is involved in memory
reclaim.

The corruption can be seen in crashes, but the root cause is often
difficult to ascertain as a crashing machine's stack trace will have no
evidence of being near NFS or SUNRPC code. I believe this problem to
be much more pervasive than reports to the community may indicate.

Fix this by having kernel users of sockets that may corrupt task_frag due
to reclaim set sk_use_task_frag = false. Preemptively correcting this
situation for users that still set sk_allocation allows them to convert to
memalloc_nofs_save/restore without the same unexpected corruptions that are
sure to follow, unlikely to show up in testing, and difficult to bisect.

CC: Philipp Reisner <[e-mail]>
CC: Lars Ellenberg <[e-mail]>
CC: "Christoph Böhmwalder" <[e-mail]>
CC: Jens Axboe <[e-mail]>
CC: Josef Bacik <[e-mail]>
CC: Keith Busch <[e-mail]>
CC: Christoph Hellwig <[e-mail]>
CC: Sagi Grimberg <[e-mail]>
CC: Lee Duncan <[e-mail]>
CC: Chris Leech <[e-mail]>
CC: Mike Christie <[e-mail]>
CC: "James E.J. Bottomley" <[e-mail]>
CC: "Martin K. Petersen" <[e-mail]>
CC: Valentina Manea <[e-mail]>
CC: Shuah Khan <[e-mail]>
CC: Greg Kroah-Hartman <[e-mail]>
CC: David Howells <[e-mail]>
CC: Marc Dionne <[e-mail]>
CC: Steve French <[e-mail]>
CC: Christine Caulfield <[e-mail]>
CC: David Teigland <[e-mail]>
CC: Mark Fasheh <[e-mail]>
CC: Joel Becker <[e-mail]>
CC: Joseph Qi <[e-mail]>
CC: Eric Van Hensbergen <[e-mail]>
CC: Latchesar Ionkov <[e-mail]>
CC: Dominique Martinet <[e-mail]>
CC: Ilya Dryomov <[e-mail]>
CC: Xiubo Li <[e-mail]>
CC: Chuck Lever <[e-mail]>
CC: Jeff Layton <[e-mail]>
CC: Trond Myklebust <[e-mail]>
CC: Anna Schumaker <[e-mail]>
CC: Steffen Klassert <[e-mail]>
CC: Herbert Xu <[e-mail]>

Suggested-by: Guillaume Nault <[e-mail]>
Signed-off-by: Benjamin Coddington <[e-mail]>
Reviewed-by: Guillaume Nault <[e-mail]>
Signed-off-by: Jakub Kicinski <[e-mail]>

drivers/block/drbd/drbd_receiver.c

···
 	sock.socket->sk->sk_allocation = GFP_NOIO;
 	msock.socket->sk->sk_allocation = GFP_NOIO;
 
+	sock.socket->sk->sk_use_task_frag = false;
+	msock.socket->sk->sk_use_task_frag = false;
+
 	sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
 	msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE;
 

drivers/block/nbd.c

···
 	noreclaim_flag = memalloc_noreclaim_save();
 	do {
 		sock->sk->sk_allocation = GFP_NOIO | __GFP_MEMALLOC;
+		sock->sk->sk_use_task_frag = false;
 		msg.msg_name = NULL;
 		msg.msg_namelen = 0;
 		msg.msg_control = NULL;

drivers/nvme/host/tcp.c

···
 	queue->sock->sk->sk_rcvtimeo = 10 * HZ;
 
 	queue->sock->sk->sk_allocation = GFP_ATOMIC;
+	queue->sock->sk->sk_use_task_frag = false;
 	nvme_tcp_set_queue_io_cpu(queue);
 	queue->request = NULL;
 	queue->data_remaining = 0;

drivers/scsi/iscsi_tcp.c

···
 	sk->sk_reuse = SK_CAN_REUSE;
 	sk->sk_sndtimeo = 15 * HZ; /* FIXME: make it configurable */
 	sk->sk_allocation = GFP_ATOMIC;
+	sk->sk_use_task_frag = false;
 	sk_set_memalloc(sk);
 	sock_no_linger(sk);
 

drivers/usb/usbip/usbip_common.c

···
 
 	do {
 		sock->sk->sk_allocation = GFP_NOIO;
+		sock->sk->sk_use_task_frag = false;
 
 		result = sock_recvmsg(sock, &msg, MSG_WAITALL);
 		if (result <= 0)

fs/cifs/connect.c

···
 		cifs_dbg(FYI, "Socket created\n");
 		server->ssocket = socket;
 		socket->sk->sk_allocation = GFP_NOFS;
+		socket->sk->sk_use_task_frag = false;
 		if (sfamily == AF_INET6)
 			cifs_reclassify_socket6(socket);
 		else

fs/dlm/lowcomms.c

···
 	if (dlm_config.ci_protocol == DLM_PROTO_SCTP)
 		sk->sk_state_change = lowcomms_state_change;
 	sk->sk_allocation = GFP_NOFS;
+	sk->sk_use_task_frag = false;
 	sk->sk_error_report = lowcomms_error_report;
 	release_sock(sk);
 }
···
 	listen_con.sock = sock;
 
 	sock->sk->sk_allocation = GFP_NOFS;
+	sock->sk->sk_use_task_frag = false;
 	sock->sk->sk_data_ready = lowcomms_listen_data_ready;
 	release_sock(sock->sk);
 

fs/ocfs2/cluster/tcp.c

···
 	sc->sc_sock = sock; /* freed by sc_kref_release */
 
 	sock->sk->sk_allocation = GFP_ATOMIC;
+	sock->sk->sk_use_task_frag = false;
 
 	myaddr.sin_family = AF_INET;
 	myaddr.sin_addr.s_addr = mynode->nd_ipv4_address;

net/9p/trans_fd.c

···
 	}
 
 	csocket->sk->sk_allocation = GFP_NOIO;
+	csocket->sk->sk_use_task_frag = false;
 	file = sock_alloc_file(csocket, 0, NULL);
 	if (IS_ERR(file)) {
 		pr_err("%s (%d): failed to map fd\n",

net/ceph/messenger.c

···
 	if (ret)
 		return ret;
 	sock->sk->sk_allocation = GFP_NOFS;
+	sock->sk->sk_use_task_frag = false;
 
 #ifdef CONFIG_LOCKDEP
 	lockdep_set_class(&sock->sk->sk_lock, &socket_class);

net/sunrpc/xprtsock.c

···
 		sk->sk_write_space = xs_udp_write_space;
 		sk->sk_state_change = xs_local_state_change;
 		sk->sk_error_report = xs_error_report;
+		sk->sk_use_task_frag = false;
 
 		xprt_clear_connected(xprt);
 
···
 		sk->sk_user_data = xprt;
 		sk->sk_data_ready = xs_data_ready;
 		sk->sk_write_space = xs_udp_write_space;
+		sk->sk_use_task_frag = false;
 
 		xprt_set_connected(xprt);
 
···
 		sk->sk_state_change = xs_tcp_state_change;
 		sk->sk_write_space = xs_tcp_write_space;
 		sk->sk_error_report = xs_error_report;
+		sk->sk_use_task_frag = false;
 
 		/* socket options */
 		sock_reset_flag(sk, SOCK_LINGER);

net/xfrm/espintcp.c

···
 
 	/* avoid using task_frag */
 	sk->sk_allocation = GFP_ATOMIC;
+	sk->sk_use_task_frag = false;
 
 	return 0;