1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  *
4  *   vfs operations that deal with files
5  *
6  *   Copyright (C) International Business Machines  Corp., 2002,2010
7  *   Author(s): Steve French (sfrench@us.ibm.com)
8  *              Jeremy Allison (jra@samba.org)
9  *
10  */
11 #include <linux/fs.h>
12 #include <linux/backing-dev.h>
13 #include <linux/stat.h>
14 #include <linux/fcntl.h>
15 #include <linux/pagemap.h>
16 #include <linux/pagevec.h>
17 #include <linux/writeback.h>
18 #include <linux/task_io_accounting_ops.h>
19 #include <linux/delay.h>
20 #include <linux/mount.h>
21 #include <linux/slab.h>
22 #include <linux/swap.h>
23 #include <linux/mm.h>
24 #include <asm/div64.h>
25 #include "cifsfs.h"
26 #include "cifspdu.h"
27 #include "cifsglob.h"
28 #include "cifsproto.h"
29 #include "smb2proto.h"
30 #include "cifs_unicode.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
33 #include "fscache.h"
34 #include "smbdirect.h"
35 #include "fs_context.h"
36 #include "cifs_ioctl.h"
37 #include "cached_dir.h"
38 
39 /*
40  * Mark as invalid, all open files on tree connections since they
41  * were closed when session to server was lost.
42  */
43 void
cifs_mark_open_files_invalid(struct cifs_tcon * tcon)44 cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
45 {
46 	struct cifsFileInfo *open_file = NULL;
47 	struct list_head *tmp;
48 	struct list_head *tmp1;
49 
50 	/* only send once per connect */
51 	spin_lock(&tcon->ses->ses_lock);
52 	if ((tcon->ses->ses_status != SES_GOOD) || (tcon->status != TID_NEED_RECON)) {
53 		spin_unlock(&tcon->ses->ses_lock);
54 		return;
55 	}
56 	tcon->status = TID_IN_FILES_INVALIDATE;
57 	spin_unlock(&tcon->ses->ses_lock);
58 
59 	/* list all files open on tree connection and mark them invalid */
60 	spin_lock(&tcon->open_file_lock);
61 	list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
62 		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
63 		open_file->invalidHandle = true;
64 		open_file->oplock_break_cancelled = true;
65 	}
66 	spin_unlock(&tcon->open_file_lock);
67 
68 	invalidate_all_cached_dirs(tcon);
69 	spin_lock(&tcon->tc_lock);
70 	if (tcon->status == TID_IN_FILES_INVALIDATE)
71 		tcon->status = TID_NEED_TCON;
72 	spin_unlock(&tcon->tc_lock);
73 
74 	/*
75 	 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
76 	 * to this tcon.
77 	 */
78 }
79 
cifs_convert_flags(unsigned int flags)80 static inline int cifs_convert_flags(unsigned int flags)
81 {
82 	if ((flags & O_ACCMODE) == O_RDONLY)
83 		return GENERIC_READ;
84 	else if ((flags & O_ACCMODE) == O_WRONLY)
85 		return GENERIC_WRITE;
86 	else if ((flags & O_ACCMODE) == O_RDWR) {
87 		/* GENERIC_ALL is too much permission to request
88 		   can cause unnecessary access denied on create */
89 		/* return GENERIC_ALL; */
90 		return (GENERIC_READ | GENERIC_WRITE);
91 	}
92 
93 	return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
94 		FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
95 		FILE_READ_DATA);
96 }
97 
98 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
cifs_posix_convert_flags(unsigned int flags)99 static u32 cifs_posix_convert_flags(unsigned int flags)
100 {
101 	u32 posix_flags = 0;
102 
103 	if ((flags & O_ACCMODE) == O_RDONLY)
104 		posix_flags = SMB_O_RDONLY;
105 	else if ((flags & O_ACCMODE) == O_WRONLY)
106 		posix_flags = SMB_O_WRONLY;
107 	else if ((flags & O_ACCMODE) == O_RDWR)
108 		posix_flags = SMB_O_RDWR;
109 
110 	if (flags & O_CREAT) {
111 		posix_flags |= SMB_O_CREAT;
112 		if (flags & O_EXCL)
113 			posix_flags |= SMB_O_EXCL;
114 	} else if (flags & O_EXCL)
115 		cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
116 			 current->comm, current->tgid);
117 
118 	if (flags & O_TRUNC)
119 		posix_flags |= SMB_O_TRUNC;
120 	/* be safe and imply O_SYNC for O_DSYNC */
121 	if (flags & O_DSYNC)
122 		posix_flags |= SMB_O_SYNC;
123 	if (flags & O_DIRECTORY)
124 		posix_flags |= SMB_O_DIRECTORY;
125 	if (flags & O_NOFOLLOW)
126 		posix_flags |= SMB_O_NOFOLLOW;
127 	if (flags & O_DIRECT)
128 		posix_flags |= SMB_O_DIRECT;
129 
130 	return posix_flags;
131 }
132 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
133 
cifs_get_disposition(unsigned int flags)134 static inline int cifs_get_disposition(unsigned int flags)
135 {
136 	if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
137 		return FILE_CREATE;
138 	else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
139 		return FILE_OVERWRITE_IF;
140 	else if ((flags & O_CREAT) == O_CREAT)
141 		return FILE_OPEN_IF;
142 	else if ((flags & O_TRUNC) == O_TRUNC)
143 		return FILE_OVERWRITE;
144 	else
145 		return FILE_OPEN;
146 }
147 
148 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
cifs_posix_open(const char * full_path,struct inode ** pinode,struct super_block * sb,int mode,unsigned int f_flags,__u32 * poplock,__u16 * pnetfid,unsigned int xid)149 int cifs_posix_open(const char *full_path, struct inode **pinode,
150 			struct super_block *sb, int mode, unsigned int f_flags,
151 			__u32 *poplock, __u16 *pnetfid, unsigned int xid)
152 {
153 	int rc;
154 	FILE_UNIX_BASIC_INFO *presp_data;
155 	__u32 posix_flags = 0;
156 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
157 	struct cifs_fattr fattr;
158 	struct tcon_link *tlink;
159 	struct cifs_tcon *tcon;
160 
161 	cifs_dbg(FYI, "posix open %s\n", full_path);
162 
163 	presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
164 	if (presp_data == NULL)
165 		return -ENOMEM;
166 
167 	tlink = cifs_sb_tlink(cifs_sb);
168 	if (IS_ERR(tlink)) {
169 		rc = PTR_ERR(tlink);
170 		goto posix_open_ret;
171 	}
172 
173 	tcon = tlink_tcon(tlink);
174 	mode &= ~current_umask();
175 
176 	posix_flags = cifs_posix_convert_flags(f_flags);
177 	rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
178 			     poplock, full_path, cifs_sb->local_nls,
179 			     cifs_remap(cifs_sb));
180 	cifs_put_tlink(tlink);
181 
182 	if (rc)
183 		goto posix_open_ret;
184 
185 	if (presp_data->Type == cpu_to_le32(-1))
186 		goto posix_open_ret; /* open ok, caller does qpathinfo */
187 
188 	if (!pinode)
189 		goto posix_open_ret; /* caller does not need info */
190 
191 	cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
192 
193 	/* get new inode and set it up */
194 	if (*pinode == NULL) {
195 		cifs_fill_uniqueid(sb, &fattr);
196 		*pinode = cifs_iget(sb, &fattr);
197 		if (!*pinode) {
198 			rc = -ENOMEM;
199 			goto posix_open_ret;
200 		}
201 	} else {
202 		cifs_revalidate_mapping(*pinode);
203 		rc = cifs_fattr_to_inode(*pinode, &fattr);
204 	}
205 
206 posix_open_ret:
207 	kfree(presp_data);
208 	return rc;
209 }
210 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
211 
cifs_nt_open(const char * full_path,struct inode * inode,struct cifs_sb_info * cifs_sb,struct cifs_tcon * tcon,unsigned int f_flags,__u32 * oplock,struct cifs_fid * fid,unsigned int xid,struct cifs_open_info_data * buf)212 static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
213 			struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
214 			struct cifs_fid *fid, unsigned int xid, struct cifs_open_info_data *buf)
215 {
216 	int rc;
217 	int desired_access;
218 	int disposition;
219 	int create_options = CREATE_NOT_DIR;
220 	struct TCP_Server_Info *server = tcon->ses->server;
221 	struct cifs_open_parms oparms;
222 
223 	if (!server->ops->open)
224 		return -ENOSYS;
225 
226 	desired_access = cifs_convert_flags(f_flags);
227 
228 /*********************************************************************
229  *  open flag mapping table:
230  *
231  *	POSIX Flag            CIFS Disposition
232  *	----------            ----------------
233  *	O_CREAT               FILE_OPEN_IF
234  *	O_CREAT | O_EXCL      FILE_CREATE
235  *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
236  *	O_TRUNC               FILE_OVERWRITE
237  *	none of the above     FILE_OPEN
238  *
239  *	Note that there is not a direct match between disposition
240  *	FILE_SUPERSEDE (ie create whether or not file exists although
241  *	O_CREAT | O_TRUNC is similar but truncates the existing
242  *	file rather than creating a new file as FILE_SUPERSEDE does
243  *	(which uses the attributes / metadata passed in on open call)
244  *?
245  *?  O_SYNC is a reasonable match to CIFS writethrough flag
246  *?  and the read write flags match reasonably.  O_LARGEFILE
247  *?  is irrelevant because largefile support is always used
248  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
249  *	 O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
250  *********************************************************************/
251 
252 	disposition = cifs_get_disposition(f_flags);
253 
254 	/* BB pass O_SYNC flag through on file attributes .. BB */
255 
256 	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
257 	if (f_flags & O_SYNC)
258 		create_options |= CREATE_WRITE_THROUGH;
259 
260 	if (f_flags & O_DIRECT)
261 		create_options |= CREATE_NO_BUFFER;
262 
263 	oparms.tcon = tcon;
264 	oparms.cifs_sb = cifs_sb;
265 	oparms.desired_access = desired_access;
266 	oparms.create_options = cifs_create_options(cifs_sb, create_options);
267 	oparms.disposition = disposition;
268 	oparms.path = full_path;
269 	oparms.fid = fid;
270 	oparms.reconnect = false;
271 
272 	rc = server->ops->open(xid, &oparms, oplock, buf);
273 	if (rc)
274 		return rc;
275 
276 	/* TODO: Add support for calling posix query info but with passing in fid */
277 	if (tcon->unix_ext)
278 		rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
279 					      xid);
280 	else
281 		rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
282 					 xid, fid);
283 
284 	if (rc) {
285 		server->ops->close(xid, tcon, fid);
286 		if (rc == -ESTALE)
287 			rc = -EOPENSTALE;
288 	}
289 
290 	return rc;
291 }
292 
293 static bool
cifs_has_mand_locks(struct cifsInodeInfo * cinode)294 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
295 {
296 	struct cifs_fid_locks *cur;
297 	bool has_locks = false;
298 
299 	down_read(&cinode->lock_sem);
300 	list_for_each_entry(cur, &cinode->llist, llist) {
301 		if (!list_empty(&cur->locks)) {
302 			has_locks = true;
303 			break;
304 		}
305 	}
306 	up_read(&cinode->lock_sem);
307 	return has_locks;
308 }
309 
310 void
cifs_down_write(struct rw_semaphore * sem)311 cifs_down_write(struct rw_semaphore *sem)
312 {
313 	while (!down_write_trylock(sem))
314 		msleep(10);
315 }
316 
317 static void cifsFileInfo_put_work(struct work_struct *work);
318 
cifs_new_fileinfo(struct cifs_fid * fid,struct file * file,struct tcon_link * tlink,__u32 oplock,const char * symlink_target)319 struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
320 				       struct tcon_link *tlink, __u32 oplock,
321 				       const char *symlink_target)
322 {
323 	struct dentry *dentry = file_dentry(file);
324 	struct inode *inode = d_inode(dentry);
325 	struct cifsInodeInfo *cinode = CIFS_I(inode);
326 	struct cifsFileInfo *cfile;
327 	struct cifs_fid_locks *fdlocks;
328 	struct cifs_tcon *tcon = tlink_tcon(tlink);
329 	struct TCP_Server_Info *server = tcon->ses->server;
330 
331 	cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
332 	if (cfile == NULL)
333 		return cfile;
334 
335 	fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
336 	if (!fdlocks) {
337 		kfree(cfile);
338 		return NULL;
339 	}
340 
341 	if (symlink_target) {
342 		cfile->symlink_target = kstrdup(symlink_target, GFP_KERNEL);
343 		if (!cfile->symlink_target) {
344 			kfree(fdlocks);
345 			kfree(cfile);
346 			return NULL;
347 		}
348 	}
349 
350 	INIT_LIST_HEAD(&fdlocks->locks);
351 	fdlocks->cfile = cfile;
352 	cfile->llist = fdlocks;
353 
354 	cfile->count = 1;
355 	cfile->pid = current->tgid;
356 	cfile->uid = current_fsuid();
357 	cfile->dentry = dget(dentry);
358 	cfile->f_flags = file->f_flags;
359 	cfile->invalidHandle = false;
360 	cfile->deferred_close_scheduled = false;
361 	cfile->tlink = cifs_get_tlink(tlink);
362 	INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
363 	INIT_WORK(&cfile->put, cifsFileInfo_put_work);
364 	INIT_DELAYED_WORK(&cfile->deferred, smb2_deferred_work_close);
365 	mutex_init(&cfile->fh_mutex);
366 	spin_lock_init(&cfile->file_info_lock);
367 
368 	cifs_sb_active(inode->i_sb);
369 
370 	/*
371 	 * If the server returned a read oplock and we have mandatory brlocks,
372 	 * set oplock level to None.
373 	 */
374 	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
375 		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
376 		oplock = 0;
377 	}
378 
379 	cifs_down_write(&cinode->lock_sem);
380 	list_add(&fdlocks->llist, &cinode->llist);
381 	up_write(&cinode->lock_sem);
382 
383 	spin_lock(&tcon->open_file_lock);
384 	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
385 		oplock = fid->pending_open->oplock;
386 	list_del(&fid->pending_open->olist);
387 
388 	fid->purge_cache = false;
389 	server->ops->set_fid(cfile, fid, oplock);
390 
391 	list_add(&cfile->tlist, &tcon->openFileList);
392 	atomic_inc(&tcon->num_local_opens);
393 
394 	/* if readable file instance put first in list*/
395 	spin_lock(&cinode->open_file_lock);
396 	if (file->f_mode & FMODE_READ)
397 		list_add(&cfile->flist, &cinode->openFileList);
398 	else
399 		list_add_tail(&cfile->flist, &cinode->openFileList);
400 	spin_unlock(&cinode->open_file_lock);
401 	spin_unlock(&tcon->open_file_lock);
402 
403 	if (fid->purge_cache)
404 		cifs_zap_mapping(inode);
405 
406 	file->private_data = cfile;
407 	return cfile;
408 }
409 
410 struct cifsFileInfo *
cifsFileInfo_get(struct cifsFileInfo * cifs_file)411 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
412 {
413 	spin_lock(&cifs_file->file_info_lock);
414 	cifsFileInfo_get_locked(cifs_file);
415 	spin_unlock(&cifs_file->file_info_lock);
416 	return cifs_file;
417 }
418 
cifsFileInfo_put_final(struct cifsFileInfo * cifs_file)419 static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file)
420 {
421 	struct inode *inode = d_inode(cifs_file->dentry);
422 	struct cifsInodeInfo *cifsi = CIFS_I(inode);
423 	struct cifsLockInfo *li, *tmp;
424 	struct super_block *sb = inode->i_sb;
425 
426 	/*
427 	 * Delete any outstanding lock records. We'll lose them when the file
428 	 * is closed anyway.
429 	 */
430 	cifs_down_write(&cifsi->lock_sem);
431 	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
432 		list_del(&li->llist);
433 		cifs_del_lock_waiters(li);
434 		kfree(li);
435 	}
436 	list_del(&cifs_file->llist->llist);
437 	kfree(cifs_file->llist);
438 	up_write(&cifsi->lock_sem);
439 
440 	cifs_put_tlink(cifs_file->tlink);
441 	dput(cifs_file->dentry);
442 	cifs_sb_deactive(sb);
443 	kfree(cifs_file->symlink_target);
444 	kfree(cifs_file);
445 }
446 
cifsFileInfo_put_work(struct work_struct * work)447 static void cifsFileInfo_put_work(struct work_struct *work)
448 {
449 	struct cifsFileInfo *cifs_file = container_of(work,
450 			struct cifsFileInfo, put);
451 
452 	cifsFileInfo_put_final(cifs_file);
453 }
454 
455 /**
456  * cifsFileInfo_put - release a reference of file priv data
457  *
458  * Always potentially wait for oplock handler. See _cifsFileInfo_put().
459  *
460  * @cifs_file:	cifs/smb3 specific info (eg refcounts) for an open file
461  */
cifsFileInfo_put(struct cifsFileInfo * cifs_file)462 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
463 {
464 	_cifsFileInfo_put(cifs_file, true, true);
465 }
466 
467 /**
468  * _cifsFileInfo_put - release a reference of file priv data
469  *
470  * This may involve closing the filehandle @cifs_file out on the
471  * server. Must be called without holding tcon->open_file_lock,
472  * cinode->open_file_lock and cifs_file->file_info_lock.
473  *
474  * If @wait_for_oplock_handler is true and we are releasing the last
475  * reference, wait for any running oplock break handler of the file
476  * and cancel any pending one.
477  *
478  * @cifs_file:	cifs/smb3 specific info (eg refcounts) for an open file
479  * @wait_oplock_handler: must be false if called from oplock_break_handler
480  * @offload:	not offloaded on close and oplock breaks
481  *
482  */
_cifsFileInfo_put(struct cifsFileInfo * cifs_file,bool wait_oplock_handler,bool offload)483 void _cifsFileInfo_put(struct cifsFileInfo *cifs_file,
484 		       bool wait_oplock_handler, bool offload)
485 {
486 	struct inode *inode = d_inode(cifs_file->dentry);
487 	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
488 	struct TCP_Server_Info *server = tcon->ses->server;
489 	struct cifsInodeInfo *cifsi = CIFS_I(inode);
490 	struct super_block *sb = inode->i_sb;
491 	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
492 	struct cifs_fid fid = {};
493 	struct cifs_pending_open open;
494 	bool oplock_break_cancelled;
495 
496 	spin_lock(&tcon->open_file_lock);
497 	spin_lock(&cifsi->open_file_lock);
498 	spin_lock(&cifs_file->file_info_lock);
499 	if (--cifs_file->count > 0) {
500 		spin_unlock(&cifs_file->file_info_lock);
501 		spin_unlock(&cifsi->open_file_lock);
502 		spin_unlock(&tcon->open_file_lock);
503 		return;
504 	}
505 	spin_unlock(&cifs_file->file_info_lock);
506 
507 	if (server->ops->get_lease_key)
508 		server->ops->get_lease_key(inode, &fid);
509 
510 	/* store open in pending opens to make sure we don't miss lease break */
511 	cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
512 
513 	/* remove it from the lists */
514 	list_del(&cifs_file->flist);
515 	list_del(&cifs_file->tlist);
516 	atomic_dec(&tcon->num_local_opens);
517 
518 	if (list_empty(&cifsi->openFileList)) {
519 		cifs_dbg(FYI, "closing last open instance for inode %p\n",
520 			 d_inode(cifs_file->dentry));
521 		/*
522 		 * In strict cache mode we need invalidate mapping on the last
523 		 * close  because it may cause a error when we open this file
524 		 * again and get at least level II oplock.
525 		 */
526 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
527 			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
528 		cifs_set_oplock_level(cifsi, 0);
529 	}
530 
531 	spin_unlock(&cifsi->open_file_lock);
532 	spin_unlock(&tcon->open_file_lock);
533 
534 	oplock_break_cancelled = wait_oplock_handler ?
535 		cancel_work_sync(&cifs_file->oplock_break) : false;
536 
537 	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
538 		struct TCP_Server_Info *server = tcon->ses->server;
539 		unsigned int xid;
540 
541 		xid = get_xid();
542 		if (server->ops->close_getattr)
543 			server->ops->close_getattr(xid, tcon, cifs_file);
544 		else if (server->ops->close)
545 			server->ops->close(xid, tcon, &cifs_file->fid);
546 		_free_xid(xid);
547 	}
548 
549 	if (oplock_break_cancelled)
550 		cifs_done_oplock_break(cifsi);
551 
552 	cifs_del_pending_open(&open);
553 
554 	if (offload)
555 		queue_work(fileinfo_put_wq, &cifs_file->put);
556 	else
557 		cifsFileInfo_put_final(cifs_file);
558 }
559 
cifs_open(struct inode * inode,struct file * file)560 int cifs_open(struct inode *inode, struct file *file)
561 
562 {
563 	int rc = -EACCES;
564 	unsigned int xid;
565 	__u32 oplock;
566 	struct cifs_sb_info *cifs_sb;
567 	struct TCP_Server_Info *server;
568 	struct cifs_tcon *tcon;
569 	struct tcon_link *tlink;
570 	struct cifsFileInfo *cfile = NULL;
571 	void *page;
572 	const char *full_path;
573 	bool posix_open_ok = false;
574 	struct cifs_fid fid = {};
575 	struct cifs_pending_open open;
576 	struct cifs_open_info_data data = {};
577 
578 	xid = get_xid();
579 
580 	cifs_sb = CIFS_SB(inode->i_sb);
581 	if (unlikely(cifs_forced_shutdown(cifs_sb))) {
582 		free_xid(xid);
583 		return -EIO;
584 	}
585 
586 	tlink = cifs_sb_tlink(cifs_sb);
587 	if (IS_ERR(tlink)) {
588 		free_xid(xid);
589 		return PTR_ERR(tlink);
590 	}
591 	tcon = tlink_tcon(tlink);
592 	server = tcon->ses->server;
593 
594 	page = alloc_dentry_path();
595 	full_path = build_path_from_dentry(file_dentry(file), page);
596 	if (IS_ERR(full_path)) {
597 		rc = PTR_ERR(full_path);
598 		goto out;
599 	}
600 
601 	cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
602 		 inode, file->f_flags, full_path);
603 
604 	if (file->f_flags & O_DIRECT &&
605 	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
606 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
607 			file->f_op = &cifs_file_direct_nobrl_ops;
608 		else
609 			file->f_op = &cifs_file_direct_ops;
610 	}
611 
612 	/* Get the cached handle as SMB2 close is deferred */
613 	rc = cifs_get_readable_path(tcon, full_path, &cfile);
614 	if (rc == 0) {
615 		if (file->f_flags == cfile->f_flags) {
616 			file->private_data = cfile;
617 			spin_lock(&CIFS_I(inode)->deferred_lock);
618 			cifs_del_deferred_close(cfile);
619 			spin_unlock(&CIFS_I(inode)->deferred_lock);
620 			goto use_cache;
621 		} else {
622 			_cifsFileInfo_put(cfile, true, false);
623 		}
624 	}
625 
626 	if (server->oplocks)
627 		oplock = REQ_OPLOCK;
628 	else
629 		oplock = 0;
630 
631 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
632 	if (!tcon->broken_posix_open && tcon->unix_ext &&
633 	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
634 				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
635 		/* can not refresh inode info since size could be stale */
636 		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
637 				cifs_sb->ctx->file_mode /* ignored */,
638 				file->f_flags, &oplock, &fid.netfid, xid);
639 		if (rc == 0) {
640 			cifs_dbg(FYI, "posix open succeeded\n");
641 			posix_open_ok = true;
642 		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
643 			if (tcon->ses->serverNOS)
644 				cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
645 					 tcon->ses->ip_addr,
646 					 tcon->ses->serverNOS);
647 			tcon->broken_posix_open = true;
648 		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
649 			 (rc != -EOPNOTSUPP)) /* path not found or net err */
650 			goto out;
651 		/*
652 		 * Else fallthrough to retry open the old way on network i/o
653 		 * or DFS errors.
654 		 */
655 	}
656 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
657 
658 	if (server->ops->get_lease_key)
659 		server->ops->get_lease_key(inode, &fid);
660 
661 	cifs_add_pending_open(&fid, tlink, &open);
662 
663 	if (!posix_open_ok) {
664 		if (server->ops->get_lease_key)
665 			server->ops->get_lease_key(inode, &fid);
666 
667 		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid,
668 				  xid, &data);
669 		if (rc) {
670 			cifs_del_pending_open(&open);
671 			goto out;
672 		}
673 	}
674 
675 	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock, data.symlink_target);
676 	if (cfile == NULL) {
677 		if (server->ops->close)
678 			server->ops->close(xid, tcon, &fid);
679 		cifs_del_pending_open(&open);
680 		rc = -ENOMEM;
681 		goto out;
682 	}
683 
684 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
685 	if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
686 		/*
687 		 * Time to set mode which we can not set earlier due to
688 		 * problems creating new read-only files.
689 		 */
690 		struct cifs_unix_set_info_args args = {
691 			.mode	= inode->i_mode,
692 			.uid	= INVALID_UID, /* no change */
693 			.gid	= INVALID_GID, /* no change */
694 			.ctime	= NO_CHANGE_64,
695 			.atime	= NO_CHANGE_64,
696 			.mtime	= NO_CHANGE_64,
697 			.device	= 0,
698 		};
699 		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
700 				       cfile->pid);
701 	}
702 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
703 
704 use_cache:
705 	fscache_use_cookie(cifs_inode_cookie(file_inode(file)),
706 			   file->f_mode & FMODE_WRITE);
707 	if (file->f_flags & O_DIRECT &&
708 	    (!((file->f_flags & O_ACCMODE) != O_RDONLY) ||
709 	     file->f_flags & O_APPEND))
710 		cifs_invalidate_cache(file_inode(file),
711 				      FSCACHE_INVAL_DIO_WRITE);
712 
713 out:
714 	free_dentry_path(page);
715 	free_xid(xid);
716 	cifs_put_tlink(tlink);
717 	cifs_free_open_info(&data);
718 	return rc;
719 }
720 
721 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
722 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
723 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
724 
725 /*
726  * Try to reacquire byte range locks that were released when session
727  * to server was lost.
728  */
729 static int
cifs_relock_file(struct cifsFileInfo * cfile)730 cifs_relock_file(struct cifsFileInfo *cfile)
731 {
732 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
733 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
734 	int rc = 0;
735 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
736 	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
737 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
738 
739 	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
740 	if (cinode->can_cache_brlcks) {
741 		/* can cache locks - no need to relock */
742 		up_read(&cinode->lock_sem);
743 		return rc;
744 	}
745 
746 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
747 	if (cap_unix(tcon->ses) &&
748 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
749 	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
750 		rc = cifs_push_posix_locks(cfile);
751 	else
752 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
753 		rc = tcon->ses->server->ops->push_mand_locks(cfile);
754 
755 	up_read(&cinode->lock_sem);
756 	return rc;
757 }
758 
759 static int
cifs_reopen_file(struct cifsFileInfo * cfile,bool can_flush)760 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
761 {
762 	int rc = -EACCES;
763 	unsigned int xid;
764 	__u32 oplock;
765 	struct cifs_sb_info *cifs_sb;
766 	struct cifs_tcon *tcon;
767 	struct TCP_Server_Info *server;
768 	struct cifsInodeInfo *cinode;
769 	struct inode *inode;
770 	void *page;
771 	const char *full_path;
772 	int desired_access;
773 	int disposition = FILE_OPEN;
774 	int create_options = CREATE_NOT_DIR;
775 	struct cifs_open_parms oparms;
776 
777 	xid = get_xid();
778 	mutex_lock(&cfile->fh_mutex);
779 	if (!cfile->invalidHandle) {
780 		mutex_unlock(&cfile->fh_mutex);
781 		free_xid(xid);
782 		return 0;
783 	}
784 
785 	inode = d_inode(cfile->dentry);
786 	cifs_sb = CIFS_SB(inode->i_sb);
787 	tcon = tlink_tcon(cfile->tlink);
788 	server = tcon->ses->server;
789 
790 	/*
791 	 * Can not grab rename sem here because various ops, including those
792 	 * that already have the rename sem can end up causing writepage to get
793 	 * called and if the server was down that means we end up here, and we
794 	 * can never tell if the caller already has the rename_sem.
795 	 */
796 	page = alloc_dentry_path();
797 	full_path = build_path_from_dentry(cfile->dentry, page);
798 	if (IS_ERR(full_path)) {
799 		mutex_unlock(&cfile->fh_mutex);
800 		free_dentry_path(page);
801 		free_xid(xid);
802 		return PTR_ERR(full_path);
803 	}
804 
805 	cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
806 		 inode, cfile->f_flags, full_path);
807 
808 	if (tcon->ses->server->oplocks)
809 		oplock = REQ_OPLOCK;
810 	else
811 		oplock = 0;
812 
813 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
814 	if (tcon->unix_ext && cap_unix(tcon->ses) &&
815 	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
816 				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
817 		/*
818 		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
819 		 * original open. Must mask them off for a reopen.
820 		 */
821 		unsigned int oflags = cfile->f_flags &
822 						~(O_CREAT | O_EXCL | O_TRUNC);
823 
824 		rc = cifs_posix_open(full_path, NULL, inode->i_sb,
825 				     cifs_sb->ctx->file_mode /* ignored */,
826 				     oflags, &oplock, &cfile->fid.netfid, xid);
827 		if (rc == 0) {
828 			cifs_dbg(FYI, "posix reopen succeeded\n");
829 			oparms.reconnect = true;
830 			goto reopen_success;
831 		}
832 		/*
833 		 * fallthrough to retry open the old way on errors, especially
834 		 * in the reconnect path it is important to retry hard
835 		 */
836 	}
837 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
838 
839 	desired_access = cifs_convert_flags(cfile->f_flags);
840 
841 	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
842 	if (cfile->f_flags & O_SYNC)
843 		create_options |= CREATE_WRITE_THROUGH;
844 
845 	if (cfile->f_flags & O_DIRECT)
846 		create_options |= CREATE_NO_BUFFER;
847 
848 	if (server->ops->get_lease_key)
849 		server->ops->get_lease_key(inode, &cfile->fid);
850 
851 	oparms.tcon = tcon;
852 	oparms.cifs_sb = cifs_sb;
853 	oparms.desired_access = desired_access;
854 	oparms.create_options = cifs_create_options(cifs_sb, create_options);
855 	oparms.disposition = disposition;
856 	oparms.path = full_path;
857 	oparms.fid = &cfile->fid;
858 	oparms.reconnect = true;
859 
860 	/*
861 	 * Can not refresh inode by passing in file_info buf to be returned by
862 	 * ops->open and then calling get_inode_info with returned buf since
863 	 * file might have write behind data that needs to be flushed and server
864 	 * version of file size can be stale. If we knew for sure that inode was
865 	 * not dirty locally we could do this.
866 	 */
867 	rc = server->ops->open(xid, &oparms, &oplock, NULL);
868 	if (rc == -ENOENT && oparms.reconnect == false) {
869 		/* durable handle timeout is expired - open the file again */
870 		rc = server->ops->open(xid, &oparms, &oplock, NULL);
871 		/* indicate that we need to relock the file */
872 		oparms.reconnect = true;
873 	}
874 
875 	if (rc) {
876 		mutex_unlock(&cfile->fh_mutex);
877 		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
878 		cifs_dbg(FYI, "oplock: %d\n", oplock);
879 		goto reopen_error_exit;
880 	}
881 
882 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
883 reopen_success:
884 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
885 	cfile->invalidHandle = false;
886 	mutex_unlock(&cfile->fh_mutex);
887 	cinode = CIFS_I(inode);
888 
889 	if (can_flush) {
890 		rc = filemap_write_and_wait(inode->i_mapping);
891 		if (!is_interrupt_error(rc))
892 			mapping_set_error(inode->i_mapping, rc);
893 
894 		if (tcon->posix_extensions)
895 			rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid);
896 		else if (tcon->unix_ext)
897 			rc = cifs_get_inode_info_unix(&inode, full_path,
898 						      inode->i_sb, xid);
899 		else
900 			rc = cifs_get_inode_info(&inode, full_path, NULL,
901 						 inode->i_sb, xid, NULL);
902 	}
903 	/*
904 	 * Else we are writing out data to server already and could deadlock if
905 	 * we tried to flush data, and since we do not know if we have data that
906 	 * would invalidate the current end of file on the server we can not go
907 	 * to the server to get the new inode info.
908 	 */
909 
910 	/*
911 	 * If the server returned a read oplock and we have mandatory brlocks,
912 	 * set oplock level to None.
913 	 */
914 	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
915 		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
916 		oplock = 0;
917 	}
918 
919 	server->ops->set_fid(cfile, &cfile->fid, oplock);
920 	if (oparms.reconnect)
921 		cifs_relock_file(cfile);
922 
923 reopen_error_exit:
924 	free_dentry_path(page);
925 	free_xid(xid);
926 	return rc;
927 }
928 
smb2_deferred_work_close(struct work_struct * work)929 void smb2_deferred_work_close(struct work_struct *work)
930 {
931 	struct cifsFileInfo *cfile = container_of(work,
932 			struct cifsFileInfo, deferred.work);
933 
934 	spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
935 	cifs_del_deferred_close(cfile);
936 	cfile->deferred_close_scheduled = false;
937 	spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
938 	_cifsFileInfo_put(cfile, true, false);
939 }
940 
cifs_close(struct inode * inode,struct file * file)941 int cifs_close(struct inode *inode, struct file *file)
942 {
943 	struct cifsFileInfo *cfile;
944 	struct cifsInodeInfo *cinode = CIFS_I(inode);
945 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
946 	struct cifs_deferred_close *dclose;
947 
948 	cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE);
949 
950 	if (file->private_data != NULL) {
951 		cfile = file->private_data;
952 		file->private_data = NULL;
953 		dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL);
954 		if ((cinode->oplock == CIFS_CACHE_RHW_FLG) &&
955 		    cinode->lease_granted &&
956 		    !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) &&
957 		    dclose) {
958 			if (test_and_clear_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) {
959 				inode->i_ctime = inode->i_mtime = current_time(inode);
960 			}
961 			spin_lock(&cinode->deferred_lock);
962 			cifs_add_deferred_close(cfile, dclose);
963 			if (cfile->deferred_close_scheduled &&
964 			    delayed_work_pending(&cfile->deferred)) {
965 				/*
966 				 * If there is no pending work, mod_delayed_work queues new work.
967 				 * So, Increase the ref count to avoid use-after-free.
968 				 */
969 				if (!mod_delayed_work(deferredclose_wq,
970 						&cfile->deferred, cifs_sb->ctx->closetimeo))
971 					cifsFileInfo_get(cfile);
972 			} else {
973 				/* Deferred close for files */
974 				queue_delayed_work(deferredclose_wq,
975 						&cfile->deferred, cifs_sb->ctx->closetimeo);
976 				cfile->deferred_close_scheduled = true;
977 				spin_unlock(&cinode->deferred_lock);
978 				return 0;
979 			}
980 			spin_unlock(&cinode->deferred_lock);
981 			_cifsFileInfo_put(cfile, true, false);
982 		} else {
983 			_cifsFileInfo_put(cfile, true, false);
984 			kfree(dclose);
985 		}
986 	}
987 
988 	/* return code from the ->release op is always ignored */
989 	return 0;
990 }
991 
992 void
cifs_reopen_persistent_handles(struct cifs_tcon * tcon)993 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
994 {
995 	struct cifsFileInfo *open_file, *tmp;
996 	struct list_head tmp_list;
997 
998 	if (!tcon->use_persistent || !tcon->need_reopen_files)
999 		return;
1000 
1001 	tcon->need_reopen_files = false;
1002 
1003 	cifs_dbg(FYI, "Reopen persistent handles\n");
1004 	INIT_LIST_HEAD(&tmp_list);
1005 
1006 	/* list all files open on tree connection, reopen resilient handles  */
1007 	spin_lock(&tcon->open_file_lock);
1008 	list_for_each_entry(open_file, &tcon->openFileList, tlist) {
1009 		if (!open_file->invalidHandle)
1010 			continue;
1011 		cifsFileInfo_get(open_file);
1012 		list_add_tail(&open_file->rlist, &tmp_list);
1013 	}
1014 	spin_unlock(&tcon->open_file_lock);
1015 
1016 	list_for_each_entry_safe(open_file, tmp, &tmp_list, rlist) {
1017 		if (cifs_reopen_file(open_file, false /* do not flush */))
1018 			tcon->need_reopen_files = true;
1019 		list_del_init(&open_file->rlist);
1020 		cifsFileInfo_put(open_file);
1021 	}
1022 }
1023 
cifs_closedir(struct inode * inode,struct file * file)1024 int cifs_closedir(struct inode *inode, struct file *file)
1025 {
1026 	int rc = 0;
1027 	unsigned int xid;
1028 	struct cifsFileInfo *cfile = file->private_data;
1029 	struct cifs_tcon *tcon;
1030 	struct TCP_Server_Info *server;
1031 	char *buf;
1032 
1033 	cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
1034 
1035 	if (cfile == NULL)
1036 		return rc;
1037 
1038 	xid = get_xid();
1039 	tcon = tlink_tcon(cfile->tlink);
1040 	server = tcon->ses->server;
1041 
1042 	cifs_dbg(FYI, "Freeing private data in close dir\n");
1043 	spin_lock(&cfile->file_info_lock);
1044 	if (server->ops->dir_needs_close(cfile)) {
1045 		cfile->invalidHandle = true;
1046 		spin_unlock(&cfile->file_info_lock);
1047 		if (server->ops->close_dir)
1048 			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
1049 		else
1050 			rc = -ENOSYS;
1051 		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
1052 		/* not much we can do if it fails anyway, ignore rc */
1053 		rc = 0;
1054 	} else
1055 		spin_unlock(&cfile->file_info_lock);
1056 
1057 	buf = cfile->srch_inf.ntwrk_buf_start;
1058 	if (buf) {
1059 		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
1060 		cfile->srch_inf.ntwrk_buf_start = NULL;
1061 		if (cfile->srch_inf.smallBuf)
1062 			cifs_small_buf_release(buf);
1063 		else
1064 			cifs_buf_release(buf);
1065 	}
1066 
1067 	cifs_put_tlink(cfile->tlink);
1068 	kfree(file->private_data);
1069 	file->private_data = NULL;
1070 	/* BB can we lock the filestruct while this is going on? */
1071 	free_xid(xid);
1072 	return rc;
1073 }
1074 
1075 static struct cifsLockInfo *
cifs_lock_init(__u64 offset,__u64 length,__u8 type,__u16 flags)1076 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
1077 {
1078 	struct cifsLockInfo *lock =
1079 		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
1080 	if (!lock)
1081 		return lock;
1082 	lock->offset = offset;
1083 	lock->length = length;
1084 	lock->type = type;
1085 	lock->pid = current->tgid;
1086 	lock->flags = flags;
1087 	INIT_LIST_HEAD(&lock->blist);
1088 	init_waitqueue_head(&lock->block_q);
1089 	return lock;
1090 }
1091 
1092 void
cifs_del_lock_waiters(struct cifsLockInfo * lock)1093 cifs_del_lock_waiters(struct cifsLockInfo *lock)
1094 {
1095 	struct cifsLockInfo *li, *tmp;
1096 	list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
1097 		list_del_init(&li->blist);
1098 		wake_up(&li->block_q);
1099 	}
1100 }
1101 
1102 #define CIFS_LOCK_OP	0
1103 #define CIFS_READ_OP	1
1104 #define CIFS_WRITE_OP	2
1105 
1106 /* @rw_check : 0 - no op, 1 - read, 2 - write */
1107 static bool
cifs_find_fid_lock_conflict(struct cifs_fid_locks * fdlocks,__u64 offset,__u64 length,__u8 type,__u16 flags,struct cifsFileInfo * cfile,struct cifsLockInfo ** conf_lock,int rw_check)1108 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
1109 			    __u64 length, __u8 type, __u16 flags,
1110 			    struct cifsFileInfo *cfile,
1111 			    struct cifsLockInfo **conf_lock, int rw_check)
1112 {
1113 	struct cifsLockInfo *li;
1114 	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
1115 	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1116 
1117 	list_for_each_entry(li, &fdlocks->locks, llist) {
1118 		if (offset + length <= li->offset ||
1119 		    offset >= li->offset + li->length)
1120 			continue;
1121 		if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
1122 		    server->ops->compare_fids(cfile, cur_cfile)) {
1123 			/* shared lock prevents write op through the same fid */
1124 			if (!(li->type & server->vals->shared_lock_type) ||
1125 			    rw_check != CIFS_WRITE_OP)
1126 				continue;
1127 		}
1128 		if ((type & server->vals->shared_lock_type) &&
1129 		    ((server->ops->compare_fids(cfile, cur_cfile) &&
1130 		     current->tgid == li->pid) || type == li->type))
1131 			continue;
1132 		if (rw_check == CIFS_LOCK_OP &&
1133 		    (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
1134 		    server->ops->compare_fids(cfile, cur_cfile))
1135 			continue;
1136 		if (conf_lock)
1137 			*conf_lock = li;
1138 		return true;
1139 	}
1140 	return false;
1141 }
1142 
1143 bool
cifs_find_lock_conflict(struct cifsFileInfo * cfile,__u64 offset,__u64 length,__u8 type,__u16 flags,struct cifsLockInfo ** conf_lock,int rw_check)1144 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1145 			__u8 type, __u16 flags,
1146 			struct cifsLockInfo **conf_lock, int rw_check)
1147 {
1148 	bool rc = false;
1149 	struct cifs_fid_locks *cur;
1150 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1151 
1152 	list_for_each_entry(cur, &cinode->llist, llist) {
1153 		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
1154 						 flags, cfile, conf_lock,
1155 						 rw_check);
1156 		if (rc)
1157 			break;
1158 	}
1159 
1160 	return rc;
1161 }
1162 
1163 /*
1164  * Check if there is another lock that prevents us to set the lock (mandatory
1165  * style). If such a lock exists, update the flock structure with its
1166  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1167  * or leave it the same if we can't. Returns 0 if we don't need to request to
1168  * the server or 1 otherwise.
1169  */
1170 static int
cifs_lock_test(struct cifsFileInfo * cfile,__u64 offset,__u64 length,__u8 type,struct file_lock * flock)1171 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1172 	       __u8 type, struct file_lock *flock)
1173 {
1174 	int rc = 0;
1175 	struct cifsLockInfo *conf_lock;
1176 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1177 	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1178 	bool exist;
1179 
1180 	down_read(&cinode->lock_sem);
1181 
1182 	exist = cifs_find_lock_conflict(cfile, offset, length, type,
1183 					flock->fl_flags, &conf_lock,
1184 					CIFS_LOCK_OP);
1185 	if (exist) {
1186 		flock->fl_start = conf_lock->offset;
1187 		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1188 		flock->fl_pid = conf_lock->pid;
1189 		if (conf_lock->type & server->vals->shared_lock_type)
1190 			flock->fl_type = F_RDLCK;
1191 		else
1192 			flock->fl_type = F_WRLCK;
1193 	} else if (!cinode->can_cache_brlcks)
1194 		rc = 1;
1195 	else
1196 		flock->fl_type = F_UNLCK;
1197 
1198 	up_read(&cinode->lock_sem);
1199 	return rc;
1200 }
1201 
1202 static void
cifs_lock_add(struct cifsFileInfo * cfile,struct cifsLockInfo * lock)1203 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1204 {
1205 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1206 	cifs_down_write(&cinode->lock_sem);
1207 	list_add_tail(&lock->llist, &cfile->llist->locks);
1208 	up_write(&cinode->lock_sem);
1209 }
1210 
1211 /*
1212  * Set the byte-range lock (mandatory style). Returns:
1213  * 1) 0, if we set the lock and don't need to request to the server;
1214  * 2) 1, if no locks prevent us but we need to request to the server;
1215  * 3) -EACCES, if there is a lock that prevents us and wait is false.
1216  */
1217 static int
cifs_lock_add_if(struct cifsFileInfo * cfile,struct cifsLockInfo * lock,bool wait)1218 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1219 		 bool wait)
1220 {
1221 	struct cifsLockInfo *conf_lock;
1222 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1223 	bool exist;
1224 	int rc = 0;
1225 
1226 try_again:
1227 	exist = false;
1228 	cifs_down_write(&cinode->lock_sem);
1229 
1230 	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1231 					lock->type, lock->flags, &conf_lock,
1232 					CIFS_LOCK_OP);
1233 	if (!exist && cinode->can_cache_brlcks) {
1234 		list_add_tail(&lock->llist, &cfile->llist->locks);
1235 		up_write(&cinode->lock_sem);
1236 		return rc;
1237 	}
1238 
1239 	if (!exist)
1240 		rc = 1;
1241 	else if (!wait)
1242 		rc = -EACCES;
1243 	else {
1244 		list_add_tail(&lock->blist, &conf_lock->blist);
1245 		up_write(&cinode->lock_sem);
1246 		rc = wait_event_interruptible(lock->block_q,
1247 					(lock->blist.prev == &lock->blist) &&
1248 					(lock->blist.next == &lock->blist));
1249 		if (!rc)
1250 			goto try_again;
1251 		cifs_down_write(&cinode->lock_sem);
1252 		list_del_init(&lock->blist);
1253 	}
1254 
1255 	up_write(&cinode->lock_sem);
1256 	return rc;
1257 }
1258 
1259 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1260 /*
1261  * Check if there is another lock that prevents us to set the lock (posix
1262  * style). If such a lock exists, update the flock structure with its
1263  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1264  * or leave it the same if we can't. Returns 0 if we don't need to request to
1265  * the server or 1 otherwise.
1266  */
1267 static int
cifs_posix_lock_test(struct file * file,struct file_lock * flock)1268 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1269 {
1270 	int rc = 0;
1271 	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1272 	unsigned char saved_type = flock->fl_type;
1273 
1274 	if ((flock->fl_flags & FL_POSIX) == 0)
1275 		return 1;
1276 
1277 	down_read(&cinode->lock_sem);
1278 	posix_test_lock(file, flock);
1279 
1280 	if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1281 		flock->fl_type = saved_type;
1282 		rc = 1;
1283 	}
1284 
1285 	up_read(&cinode->lock_sem);
1286 	return rc;
1287 }
1288 
1289 /*
1290  * Set the byte-range lock (posix style). Returns:
1291  * 1) <0, if the error occurs while setting the lock;
1292  * 2) 0, if we set the lock and don't need to request to the server;
1293  * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock;
1294  * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server.
1295  */
1296 static int
cifs_posix_lock_set(struct file * file,struct file_lock * flock)1297 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1298 {
1299 	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1300 	int rc = FILE_LOCK_DEFERRED + 1;
1301 
1302 	if ((flock->fl_flags & FL_POSIX) == 0)
1303 		return rc;
1304 
1305 	cifs_down_write(&cinode->lock_sem);
1306 	if (!cinode->can_cache_brlcks) {
1307 		up_write(&cinode->lock_sem);
1308 		return rc;
1309 	}
1310 
1311 	rc = posix_lock_file(file, flock, NULL);
1312 	up_write(&cinode->lock_sem);
1313 	return rc;
1314 }
1315 
1316 int
cifs_push_mandatory_locks(struct cifsFileInfo * cfile)1317 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1318 {
1319 	unsigned int xid;
1320 	int rc = 0, stored_rc;
1321 	struct cifsLockInfo *li, *tmp;
1322 	struct cifs_tcon *tcon;
1323 	unsigned int num, max_num, max_buf;
1324 	LOCKING_ANDX_RANGE *buf, *cur;
1325 	static const int types[] = {
1326 		LOCKING_ANDX_LARGE_FILES,
1327 		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1328 	};
1329 	int i;
1330 
1331 	xid = get_xid();
1332 	tcon = tlink_tcon(cfile->tlink);
1333 
1334 	/*
1335 	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1336 	 * and check it before using.
1337 	 */
1338 	max_buf = tcon->ses->server->maxBuf;
1339 	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1340 		free_xid(xid);
1341 		return -EINVAL;
1342 	}
1343 
1344 	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1345 		     PAGE_SIZE);
1346 	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1347 			PAGE_SIZE);
1348 	max_num = (max_buf - sizeof(struct smb_hdr)) /
1349 						sizeof(LOCKING_ANDX_RANGE);
1350 	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1351 	if (!buf) {
1352 		free_xid(xid);
1353 		return -ENOMEM;
1354 	}
1355 
1356 	for (i = 0; i < 2; i++) {
1357 		cur = buf;
1358 		num = 0;
1359 		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1360 			if (li->type != types[i])
1361 				continue;
1362 			cur->Pid = cpu_to_le16(li->pid);
1363 			cur->LengthLow = cpu_to_le32((u32)li->length);
1364 			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1365 			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1366 			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1367 			if (++num == max_num) {
1368 				stored_rc = cifs_lockv(xid, tcon,
1369 						       cfile->fid.netfid,
1370 						       (__u8)li->type, 0, num,
1371 						       buf);
1372 				if (stored_rc)
1373 					rc = stored_rc;
1374 				cur = buf;
1375 				num = 0;
1376 			} else
1377 				cur++;
1378 		}
1379 
1380 		if (num) {
1381 			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1382 					       (__u8)types[i], 0, num, buf);
1383 			if (stored_rc)
1384 				rc = stored_rc;
1385 		}
1386 	}
1387 
1388 	kfree(buf);
1389 	free_xid(xid);
1390 	return rc;
1391 }
1392 
1393 static __u32
hash_lockowner(fl_owner_t owner)1394 hash_lockowner(fl_owner_t owner)
1395 {
1396 	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1397 }
1398 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1399 
1400 struct lock_to_push {
1401 	struct list_head llist;
1402 	__u64 offset;
1403 	__u64 length;
1404 	__u32 pid;
1405 	__u16 netfid;
1406 	__u8 type;
1407 };
1408 
1409 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1410 static int
cifs_push_posix_locks(struct cifsFileInfo * cfile)1411 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1412 {
1413 	struct inode *inode = d_inode(cfile->dentry);
1414 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1415 	struct file_lock *flock;
1416 	struct file_lock_context *flctx = inode->i_flctx;
1417 	unsigned int count = 0, i;
1418 	int rc = 0, xid, type;
1419 	struct list_head locks_to_send, *el;
1420 	struct lock_to_push *lck, *tmp;
1421 	__u64 length;
1422 
1423 	xid = get_xid();
1424 
1425 	if (!flctx)
1426 		goto out;
1427 
1428 	spin_lock(&flctx->flc_lock);
1429 	list_for_each(el, &flctx->flc_posix) {
1430 		count++;
1431 	}
1432 	spin_unlock(&flctx->flc_lock);
1433 
1434 	INIT_LIST_HEAD(&locks_to_send);
1435 
1436 	/*
1437 	 * Allocating count locks is enough because no FL_POSIX locks can be
1438 	 * added to the list while we are holding cinode->lock_sem that
1439 	 * protects locking operations of this inode.
1440 	 */
1441 	for (i = 0; i < count; i++) {
1442 		lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1443 		if (!lck) {
1444 			rc = -ENOMEM;
1445 			goto err_out;
1446 		}
1447 		list_add_tail(&lck->llist, &locks_to_send);
1448 	}
1449 
1450 	el = locks_to_send.next;
1451 	spin_lock(&flctx->flc_lock);
1452 	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1453 		if (el == &locks_to_send) {
1454 			/*
1455 			 * The list ended. We don't have enough allocated
1456 			 * structures - something is really wrong.
1457 			 */
1458 			cifs_dbg(VFS, "Can't push all brlocks!\n");
1459 			break;
1460 		}
1461 		length = cifs_flock_len(flock);
1462 		if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1463 			type = CIFS_RDLCK;
1464 		else
1465 			type = CIFS_WRLCK;
1466 		lck = list_entry(el, struct lock_to_push, llist);
1467 		lck->pid = hash_lockowner(flock->fl_owner);
1468 		lck->netfid = cfile->fid.netfid;
1469 		lck->length = length;
1470 		lck->type = type;
1471 		lck->offset = flock->fl_start;
1472 	}
1473 	spin_unlock(&flctx->flc_lock);
1474 
1475 	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1476 		int stored_rc;
1477 
1478 		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1479 					     lck->offset, lck->length, NULL,
1480 					     lck->type, 0);
1481 		if (stored_rc)
1482 			rc = stored_rc;
1483 		list_del(&lck->llist);
1484 		kfree(lck);
1485 	}
1486 
1487 out:
1488 	free_xid(xid);
1489 	return rc;
1490 err_out:
1491 	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1492 		list_del(&lck->llist);
1493 		kfree(lck);
1494 	}
1495 	goto out;
1496 }
1497 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1498 
1499 static int
cifs_push_locks(struct cifsFileInfo * cfile)1500 cifs_push_locks(struct cifsFileInfo *cfile)
1501 {
1502 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1503 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1504 	int rc = 0;
1505 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1506 	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1507 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1508 
1509 	/* we are going to update can_cache_brlcks here - need a write access */
1510 	cifs_down_write(&cinode->lock_sem);
1511 	if (!cinode->can_cache_brlcks) {
1512 		up_write(&cinode->lock_sem);
1513 		return rc;
1514 	}
1515 
1516 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1517 	if (cap_unix(tcon->ses) &&
1518 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1519 	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1520 		rc = cifs_push_posix_locks(cfile);
1521 	else
1522 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1523 		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1524 
1525 	cinode->can_cache_brlcks = false;
1526 	up_write(&cinode->lock_sem);
1527 	return rc;
1528 }
1529 
1530 static void
cifs_read_flock(struct file_lock * flock,__u32 * type,int * lock,int * unlock,bool * wait_flag,struct TCP_Server_Info * server)1531 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1532 		bool *wait_flag, struct TCP_Server_Info *server)
1533 {
1534 	if (flock->fl_flags & FL_POSIX)
1535 		cifs_dbg(FYI, "Posix\n");
1536 	if (flock->fl_flags & FL_FLOCK)
1537 		cifs_dbg(FYI, "Flock\n");
1538 	if (flock->fl_flags & FL_SLEEP) {
1539 		cifs_dbg(FYI, "Blocking lock\n");
1540 		*wait_flag = true;
1541 	}
1542 	if (flock->fl_flags & FL_ACCESS)
1543 		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1544 	if (flock->fl_flags & FL_LEASE)
1545 		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1546 	if (flock->fl_flags &
1547 	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1548 	       FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1549 		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1550 
1551 	*type = server->vals->large_lock_type;
1552 	if (flock->fl_type == F_WRLCK) {
1553 		cifs_dbg(FYI, "F_WRLCK\n");
1554 		*type |= server->vals->exclusive_lock_type;
1555 		*lock = 1;
1556 	} else if (flock->fl_type == F_UNLCK) {
1557 		cifs_dbg(FYI, "F_UNLCK\n");
1558 		*type |= server->vals->unlock_lock_type;
1559 		*unlock = 1;
1560 		/* Check if unlock includes more than one lock range */
1561 	} else if (flock->fl_type == F_RDLCK) {
1562 		cifs_dbg(FYI, "F_RDLCK\n");
1563 		*type |= server->vals->shared_lock_type;
1564 		*lock = 1;
1565 	} else if (flock->fl_type == F_EXLCK) {
1566 		cifs_dbg(FYI, "F_EXLCK\n");
1567 		*type |= server->vals->exclusive_lock_type;
1568 		*lock = 1;
1569 	} else if (flock->fl_type == F_SHLCK) {
1570 		cifs_dbg(FYI, "F_SHLCK\n");
1571 		*type |= server->vals->shared_lock_type;
1572 		*lock = 1;
1573 	} else
1574 		cifs_dbg(FYI, "Unknown type of lock\n");
1575 }
1576 
1577 static int
cifs_getlk(struct file * file,struct file_lock * flock,__u32 type,bool wait_flag,bool posix_lck,unsigned int xid)1578 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1579 	   bool wait_flag, bool posix_lck, unsigned int xid)
1580 {
1581 	int rc = 0;
1582 	__u64 length = cifs_flock_len(flock);
1583 	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1584 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1585 	struct TCP_Server_Info *server = tcon->ses->server;
1586 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1587 	__u16 netfid = cfile->fid.netfid;
1588 
1589 	if (posix_lck) {
1590 		int posix_lock_type;
1591 
1592 		rc = cifs_posix_lock_test(file, flock);
1593 		if (!rc)
1594 			return rc;
1595 
1596 		if (type & server->vals->shared_lock_type)
1597 			posix_lock_type = CIFS_RDLCK;
1598 		else
1599 			posix_lock_type = CIFS_WRLCK;
1600 		rc = CIFSSMBPosixLock(xid, tcon, netfid,
1601 				      hash_lockowner(flock->fl_owner),
1602 				      flock->fl_start, length, flock,
1603 				      posix_lock_type, wait_flag);
1604 		return rc;
1605 	}
1606 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1607 
1608 	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1609 	if (!rc)
1610 		return rc;
1611 
1612 	/* BB we could chain these into one lock request BB */
1613 	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1614 				    1, 0, false);
1615 	if (rc == 0) {
1616 		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1617 					    type, 0, 1, false);
1618 		flock->fl_type = F_UNLCK;
1619 		if (rc != 0)
1620 			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1621 				 rc);
1622 		return 0;
1623 	}
1624 
1625 	if (type & server->vals->shared_lock_type) {
1626 		flock->fl_type = F_WRLCK;
1627 		return 0;
1628 	}
1629 
1630 	type &= ~server->vals->exclusive_lock_type;
1631 
1632 	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1633 				    type | server->vals->shared_lock_type,
1634 				    1, 0, false);
1635 	if (rc == 0) {
1636 		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1637 			type | server->vals->shared_lock_type, 0, 1, false);
1638 		flock->fl_type = F_RDLCK;
1639 		if (rc != 0)
1640 			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1641 				 rc);
1642 	} else
1643 		flock->fl_type = F_WRLCK;
1644 
1645 	return 0;
1646 }
1647 
1648 void
cifs_move_llist(struct list_head * source,struct list_head * dest)1649 cifs_move_llist(struct list_head *source, struct list_head *dest)
1650 {
1651 	struct list_head *li, *tmp;
1652 	list_for_each_safe(li, tmp, source)
1653 		list_move(li, dest);
1654 }
1655 
1656 void
cifs_free_llist(struct list_head * llist)1657 cifs_free_llist(struct list_head *llist)
1658 {
1659 	struct cifsLockInfo *li, *tmp;
1660 	list_for_each_entry_safe(li, tmp, llist, llist) {
1661 		cifs_del_lock_waiters(li);
1662 		list_del(&li->llist);
1663 		kfree(li);
1664 	}
1665 }
1666 
1667 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1668 int
cifs_unlock_range(struct cifsFileInfo * cfile,struct file_lock * flock,unsigned int xid)1669 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1670 		  unsigned int xid)
1671 {
1672 	int rc = 0, stored_rc;
1673 	static const int types[] = {
1674 		LOCKING_ANDX_LARGE_FILES,
1675 		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1676 	};
1677 	unsigned int i;
1678 	unsigned int max_num, num, max_buf;
1679 	LOCKING_ANDX_RANGE *buf, *cur;
1680 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1681 	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1682 	struct cifsLockInfo *li, *tmp;
1683 	__u64 length = cifs_flock_len(flock);
1684 	struct list_head tmp_llist;
1685 
1686 	INIT_LIST_HEAD(&tmp_llist);
1687 
1688 	/*
1689 	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1690 	 * and check it before using.
1691 	 */
1692 	max_buf = tcon->ses->server->maxBuf;
1693 	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1694 		return -EINVAL;
1695 
1696 	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1697 		     PAGE_SIZE);
1698 	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1699 			PAGE_SIZE);
1700 	max_num = (max_buf - sizeof(struct smb_hdr)) /
1701 						sizeof(LOCKING_ANDX_RANGE);
1702 	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1703 	if (!buf)
1704 		return -ENOMEM;
1705 
1706 	cifs_down_write(&cinode->lock_sem);
1707 	for (i = 0; i < 2; i++) {
1708 		cur = buf;
1709 		num = 0;
1710 		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1711 			if (flock->fl_start > li->offset ||
1712 			    (flock->fl_start + length) <
1713 			    (li->offset + li->length))
1714 				continue;
1715 			if (current->tgid != li->pid)
1716 				continue;
1717 			if (types[i] != li->type)
1718 				continue;
1719 			if (cinode->can_cache_brlcks) {
1720 				/*
1721 				 * We can cache brlock requests - simply remove
1722 				 * a lock from the file's list.
1723 				 */
1724 				list_del(&li->llist);
1725 				cifs_del_lock_waiters(li);
1726 				kfree(li);
1727 				continue;
1728 			}
1729 			cur->Pid = cpu_to_le16(li->pid);
1730 			cur->LengthLow = cpu_to_le32((u32)li->length);
1731 			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1732 			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1733 			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1734 			/*
1735 			 * We need to save a lock here to let us add it again to
1736 			 * the file's list if the unlock range request fails on
1737 			 * the server.
1738 			 */
1739 			list_move(&li->llist, &tmp_llist);
1740 			if (++num == max_num) {
1741 				stored_rc = cifs_lockv(xid, tcon,
1742 						       cfile->fid.netfid,
1743 						       li->type, num, 0, buf);
1744 				if (stored_rc) {
1745 					/*
1746 					 * We failed on the unlock range
1747 					 * request - add all locks from the tmp
1748 					 * list to the head of the file's list.
1749 					 */
1750 					cifs_move_llist(&tmp_llist,
1751 							&cfile->llist->locks);
1752 					rc = stored_rc;
1753 				} else
1754 					/*
1755 					 * The unlock range request succeed -
1756 					 * free the tmp list.
1757 					 */
1758 					cifs_free_llist(&tmp_llist);
1759 				cur = buf;
1760 				num = 0;
1761 			} else
1762 				cur++;
1763 		}
1764 		if (num) {
1765 			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1766 					       types[i], num, 0, buf);
1767 			if (stored_rc) {
1768 				cifs_move_llist(&tmp_llist,
1769 						&cfile->llist->locks);
1770 				rc = stored_rc;
1771 			} else
1772 				cifs_free_llist(&tmp_llist);
1773 		}
1774 	}
1775 
1776 	up_write(&cinode->lock_sem);
1777 	kfree(buf);
1778 	return rc;
1779 }
1780 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1781 
1782 static int
cifs_setlk(struct file * file,struct file_lock * flock,__u32 type,bool wait_flag,bool posix_lck,int lock,int unlock,unsigned int xid)1783 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1784 	   bool wait_flag, bool posix_lck, int lock, int unlock,
1785 	   unsigned int xid)
1786 {
1787 	int rc = 0;
1788 	__u64 length = cifs_flock_len(flock);
1789 	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1790 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1791 	struct TCP_Server_Info *server = tcon->ses->server;
1792 	struct inode *inode = d_inode(cfile->dentry);
1793 
1794 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1795 	if (posix_lck) {
1796 		int posix_lock_type;
1797 
1798 		rc = cifs_posix_lock_set(file, flock);
1799 		if (rc <= FILE_LOCK_DEFERRED)
1800 			return rc;
1801 
1802 		if (type & server->vals->shared_lock_type)
1803 			posix_lock_type = CIFS_RDLCK;
1804 		else
1805 			posix_lock_type = CIFS_WRLCK;
1806 
1807 		if (unlock == 1)
1808 			posix_lock_type = CIFS_UNLCK;
1809 
1810 		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1811 				      hash_lockowner(flock->fl_owner),
1812 				      flock->fl_start, length,
1813 				      NULL, posix_lock_type, wait_flag);
1814 		goto out;
1815 	}
1816 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1817 	if (lock) {
1818 		struct cifsLockInfo *lock;
1819 
1820 		lock = cifs_lock_init(flock->fl_start, length, type,
1821 				      flock->fl_flags);
1822 		if (!lock)
1823 			return -ENOMEM;
1824 
1825 		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1826 		if (rc < 0) {
1827 			kfree(lock);
1828 			return rc;
1829 		}
1830 		if (!rc)
1831 			goto out;
1832 
1833 		/*
1834 		 * Windows 7 server can delay breaking lease from read to None
1835 		 * if we set a byte-range lock on a file - break it explicitly
1836 		 * before sending the lock to the server to be sure the next
1837 		 * read won't conflict with non-overlapted locks due to
1838 		 * pagereading.
1839 		 */
1840 		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1841 					CIFS_CACHE_READ(CIFS_I(inode))) {
1842 			cifs_zap_mapping(inode);
1843 			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1844 				 inode);
1845 			CIFS_I(inode)->oplock = 0;
1846 		}
1847 
1848 		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1849 					    type, 1, 0, wait_flag);
1850 		if (rc) {
1851 			kfree(lock);
1852 			return rc;
1853 		}
1854 
1855 		cifs_lock_add(cfile, lock);
1856 	} else if (unlock)
1857 		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1858 
1859 out:
1860 	if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) {
1861 		/*
1862 		 * If this is a request to remove all locks because we
1863 		 * are closing the file, it doesn't matter if the
1864 		 * unlocking failed as both cifs.ko and the SMB server
1865 		 * remove the lock on file close
1866 		 */
1867 		if (rc) {
1868 			cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1869 			if (!(flock->fl_flags & FL_CLOSE))
1870 				return rc;
1871 		}
1872 		rc = locks_lock_file_wait(file, flock);
1873 	}
1874 	return rc;
1875 }
1876 
cifs_flock(struct file * file,int cmd,struct file_lock * fl)1877 int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
1878 {
1879 	int rc, xid;
1880 	int lock = 0, unlock = 0;
1881 	bool wait_flag = false;
1882 	bool posix_lck = false;
1883 	struct cifs_sb_info *cifs_sb;
1884 	struct cifs_tcon *tcon;
1885 	struct cifsFileInfo *cfile;
1886 	__u32 type;
1887 
1888 	xid = get_xid();
1889 
1890 	if (!(fl->fl_flags & FL_FLOCK)) {
1891 		rc = -ENOLCK;
1892 		free_xid(xid);
1893 		return rc;
1894 	}
1895 
1896 	cfile = (struct cifsFileInfo *)file->private_data;
1897 	tcon = tlink_tcon(cfile->tlink);
1898 
1899 	cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag,
1900 			tcon->ses->server);
1901 	cifs_sb = CIFS_FILE_SB(file);
1902 
1903 	if (cap_unix(tcon->ses) &&
1904 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1905 	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1906 		posix_lck = true;
1907 
1908 	if (!lock && !unlock) {
1909 		/*
1910 		 * if no lock or unlock then nothing to do since we do not
1911 		 * know what it is
1912 		 */
1913 		rc = -EOPNOTSUPP;
1914 		free_xid(xid);
1915 		return rc;
1916 	}
1917 
1918 	rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock,
1919 			xid);
1920 	free_xid(xid);
1921 	return rc;
1922 
1923 
1924 }
1925 
cifs_lock(struct file * file,int cmd,struct file_lock * flock)1926 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1927 {
1928 	int rc, xid;
1929 	int lock = 0, unlock = 0;
1930 	bool wait_flag = false;
1931 	bool posix_lck = false;
1932 	struct cifs_sb_info *cifs_sb;
1933 	struct cifs_tcon *tcon;
1934 	struct cifsFileInfo *cfile;
1935 	__u32 type;
1936 
1937 	rc = -EACCES;
1938 	xid = get_xid();
1939 
1940 	cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd,
1941 		 flock->fl_flags, flock->fl_type, (long long)flock->fl_start,
1942 		 (long long)flock->fl_end);
1943 
1944 	cfile = (struct cifsFileInfo *)file->private_data;
1945 	tcon = tlink_tcon(cfile->tlink);
1946 
1947 	cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1948 			tcon->ses->server);
1949 	cifs_sb = CIFS_FILE_SB(file);
1950 	set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);
1951 
1952 	if (cap_unix(tcon->ses) &&
1953 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1954 	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1955 		posix_lck = true;
1956 	/*
1957 	 * BB add code here to normalize offset and length to account for
1958 	 * negative length which we can not accept over the wire.
1959 	 */
1960 	if (IS_GETLK(cmd)) {
1961 		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1962 		free_xid(xid);
1963 		return rc;
1964 	}
1965 
1966 	if (!lock && !unlock) {
1967 		/*
1968 		 * if no lock or unlock then nothing to do since we do not
1969 		 * know what it is
1970 		 */
1971 		free_xid(xid);
1972 		return -EOPNOTSUPP;
1973 	}
1974 
1975 	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1976 			xid);
1977 	free_xid(xid);
1978 	return rc;
1979 }
1980 
1981 /*
1982  * update the file size (if needed) after a write. Should be called with
1983  * the inode->i_lock held
1984  */
1985 void
cifs_update_eof(struct cifsInodeInfo * cifsi,loff_t offset,unsigned int bytes_written)1986 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1987 		      unsigned int bytes_written)
1988 {
1989 	loff_t end_of_write = offset + bytes_written;
1990 
1991 	if (end_of_write > cifsi->server_eof)
1992 		cifsi->server_eof = end_of_write;
1993 }
1994 
1995 static ssize_t
cifs_write(struct cifsFileInfo * open_file,__u32 pid,const char * write_data,size_t write_size,loff_t * offset)1996 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1997 	   size_t write_size, loff_t *offset)
1998 {
1999 	int rc = 0;
2000 	unsigned int bytes_written = 0;
2001 	unsigned int total_written;
2002 	struct cifs_tcon *tcon;
2003 	struct TCP_Server_Info *server;
2004 	unsigned int xid;
2005 	struct dentry *dentry = open_file->dentry;
2006 	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
2007 	struct cifs_io_parms io_parms = {0};
2008 
2009 	cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
2010 		 write_size, *offset, dentry);
2011 
2012 	tcon = tlink_tcon(open_file->tlink);
2013 	server = tcon->ses->server;
2014 
2015 	if (!server->ops->sync_write)
2016 		return -ENOSYS;
2017 
2018 	xid = get_xid();
2019 
2020 	for (total_written = 0; write_size > total_written;
2021 	     total_written += bytes_written) {
2022 		rc = -EAGAIN;
2023 		while (rc == -EAGAIN) {
2024 			struct kvec iov[2];
2025 			unsigned int len;
2026 
2027 			if (open_file->invalidHandle) {
2028 				/* we could deadlock if we called
2029 				   filemap_fdatawait from here so tell
2030 				   reopen_file not to flush data to
2031 				   server now */
2032 				rc = cifs_reopen_file(open_file, false);
2033 				if (rc != 0)
2034 					break;
2035 			}
2036 
2037 			len = min(server->ops->wp_retry_size(d_inode(dentry)),
2038 				  (unsigned int)write_size - total_written);
2039 			/* iov[0] is reserved for smb header */
2040 			iov[1].iov_base = (char *)write_data + total_written;
2041 			iov[1].iov_len = len;
2042 			io_parms.pid = pid;
2043 			io_parms.tcon = tcon;
2044 			io_parms.offset = *offset;
2045 			io_parms.length = len;
2046 			rc = server->ops->sync_write(xid, &open_file->fid,
2047 					&io_parms, &bytes_written, iov, 1);
2048 		}
2049 		if (rc || (bytes_written == 0)) {
2050 			if (total_written)
2051 				break;
2052 			else {
2053 				free_xid(xid);
2054 				return rc;
2055 			}
2056 		} else {
2057 			spin_lock(&d_inode(dentry)->i_lock);
2058 			cifs_update_eof(cifsi, *offset, bytes_written);
2059 			spin_unlock(&d_inode(dentry)->i_lock);
2060 			*offset += bytes_written;
2061 		}
2062 	}
2063 
2064 	cifs_stats_bytes_written(tcon, total_written);
2065 
2066 	if (total_written > 0) {
2067 		spin_lock(&d_inode(dentry)->i_lock);
2068 		if (*offset > d_inode(dentry)->i_size) {
2069 			i_size_write(d_inode(dentry), *offset);
2070 			d_inode(dentry)->i_blocks = (512 - 1 + *offset) >> 9;
2071 		}
2072 		spin_unlock(&d_inode(dentry)->i_lock);
2073 	}
2074 	mark_inode_dirty_sync(d_inode(dentry));
2075 	free_xid(xid);
2076 	return total_written;
2077 }
2078 
find_readable_file(struct cifsInodeInfo * cifs_inode,bool fsuid_only)2079 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
2080 					bool fsuid_only)
2081 {
2082 	struct cifsFileInfo *open_file = NULL;
2083 	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2084 
2085 	/* only filter by fsuid on multiuser mounts */
2086 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2087 		fsuid_only = false;
2088 
2089 	spin_lock(&cifs_inode->open_file_lock);
2090 	/* we could simply get the first_list_entry since write-only entries
2091 	   are always at the end of the list but since the first entry might
2092 	   have a close pending, we go through the whole list */
2093 	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2094 		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2095 			continue;
2096 		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
2097 			if ((!open_file->invalidHandle)) {
2098 				/* found a good file */
2099 				/* lock it so it will not be closed on us */
2100 				cifsFileInfo_get(open_file);
2101 				spin_unlock(&cifs_inode->open_file_lock);
2102 				return open_file;
2103 			} /* else might as well continue, and look for
2104 			     another, or simply have the caller reopen it
2105 			     again rather than trying to fix this handle */
2106 		} else /* write only file */
2107 			break; /* write only files are last so must be done */
2108 	}
2109 	spin_unlock(&cifs_inode->open_file_lock);
2110 	return NULL;
2111 }
2112 
2113 /* Return -EBADF if no handle is found and general rc otherwise */
2114 int
cifs_get_writable_file(struct cifsInodeInfo * cifs_inode,int flags,struct cifsFileInfo ** ret_file)2115 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags,
2116 		       struct cifsFileInfo **ret_file)
2117 {
2118 	struct cifsFileInfo *open_file, *inv_file = NULL;
2119 	struct cifs_sb_info *cifs_sb;
2120 	bool any_available = false;
2121 	int rc = -EBADF;
2122 	unsigned int refind = 0;
2123 	bool fsuid_only = flags & FIND_WR_FSUID_ONLY;
2124 	bool with_delete = flags & FIND_WR_WITH_DELETE;
2125 	*ret_file = NULL;
2126 
2127 	/*
2128 	 * Having a null inode here (because mapping->host was set to zero by
2129 	 * the VFS or MM) should not happen but we had reports of on oops (due
2130 	 * to it being zero) during stress testcases so we need to check for it
2131 	 */
2132 
2133 	if (cifs_inode == NULL) {
2134 		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2135 		dump_stack();
2136 		return rc;
2137 	}
2138 
2139 	cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2140 
2141 	/* only filter by fsuid on multiuser mounts */
2142 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2143 		fsuid_only = false;
2144 
2145 	spin_lock(&cifs_inode->open_file_lock);
2146 refind_writable:
2147 	if (refind > MAX_REOPEN_ATT) {
2148 		spin_unlock(&cifs_inode->open_file_lock);
2149 		return rc;
2150 	}
2151 	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2152 		if (!any_available && open_file->pid != current->tgid)
2153 			continue;
2154 		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2155 			continue;
2156 		if (with_delete && !(open_file->fid.access & DELETE))
2157 			continue;
2158 		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2159 			if (!open_file->invalidHandle) {
2160 				/* found a good writable file */
2161 				cifsFileInfo_get(open_file);
2162 				spin_unlock(&cifs_inode->open_file_lock);
2163 				*ret_file = open_file;
2164 				return 0;
2165 			} else {
2166 				if (!inv_file)
2167 					inv_file = open_file;
2168 			}
2169 		}
2170 	}
2171 	/* couldn't find useable FH with same pid, try any available */
2172 	if (!any_available) {
2173 		any_available = true;
2174 		goto refind_writable;
2175 	}
2176 
2177 	if (inv_file) {
2178 		any_available = false;
2179 		cifsFileInfo_get(inv_file);
2180 	}
2181 
2182 	spin_unlock(&cifs_inode->open_file_lock);
2183 
2184 	if (inv_file) {
2185 		rc = cifs_reopen_file(inv_file, false);
2186 		if (!rc) {
2187 			*ret_file = inv_file;
2188 			return 0;
2189 		}
2190 
2191 		spin_lock(&cifs_inode->open_file_lock);
2192 		list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
2193 		spin_unlock(&cifs_inode->open_file_lock);
2194 		cifsFileInfo_put(inv_file);
2195 		++refind;
2196 		inv_file = NULL;
2197 		spin_lock(&cifs_inode->open_file_lock);
2198 		goto refind_writable;
2199 	}
2200 
2201 	return rc;
2202 }
2203 
2204 struct cifsFileInfo *
find_writable_file(struct cifsInodeInfo * cifs_inode,int flags)2205 find_writable_file(struct cifsInodeInfo *cifs_inode, int flags)
2206 {
2207 	struct cifsFileInfo *cfile;
2208 	int rc;
2209 
2210 	rc = cifs_get_writable_file(cifs_inode, flags, &cfile);
2211 	if (rc)
2212 		cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc);
2213 
2214 	return cfile;
2215 }
2216 
2217 int
cifs_get_writable_path(struct cifs_tcon * tcon,const char * name,int flags,struct cifsFileInfo ** ret_file)2218 cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
2219 		       int flags,
2220 		       struct cifsFileInfo **ret_file)
2221 {
2222 	struct cifsFileInfo *cfile;
2223 	void *page = alloc_dentry_path();
2224 
2225 	*ret_file = NULL;
2226 
2227 	spin_lock(&tcon->open_file_lock);
2228 	list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2229 		struct cifsInodeInfo *cinode;
2230 		const char *full_path = build_path_from_dentry(cfile->dentry, page);
2231 		if (IS_ERR(full_path)) {
2232 			spin_unlock(&tcon->open_file_lock);
2233 			free_dentry_path(page);
2234 			return PTR_ERR(full_path);
2235 		}
2236 		if (strcmp(full_path, name))
2237 			continue;
2238 
2239 		cinode = CIFS_I(d_inode(cfile->dentry));
2240 		spin_unlock(&tcon->open_file_lock);
2241 		free_dentry_path(page);
2242 		return cifs_get_writable_file(cinode, flags, ret_file);
2243 	}
2244 
2245 	spin_unlock(&tcon->open_file_lock);
2246 	free_dentry_path(page);
2247 	return -ENOENT;
2248 }
2249 
2250 int
cifs_get_readable_path(struct cifs_tcon * tcon,const char * name,struct cifsFileInfo ** ret_file)2251 cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2252 		       struct cifsFileInfo **ret_file)
2253 {
2254 	struct cifsFileInfo *cfile;
2255 	void *page = alloc_dentry_path();
2256 
2257 	*ret_file = NULL;
2258 
2259 	spin_lock(&tcon->open_file_lock);
2260 	list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2261 		struct cifsInodeInfo *cinode;
2262 		const char *full_path = build_path_from_dentry(cfile->dentry, page);
2263 		if (IS_ERR(full_path)) {
2264 			spin_unlock(&tcon->open_file_lock);
2265 			free_dentry_path(page);
2266 			return PTR_ERR(full_path);
2267 		}
2268 		if (strcmp(full_path, name))
2269 			continue;
2270 
2271 		cinode = CIFS_I(d_inode(cfile->dentry));
2272 		spin_unlock(&tcon->open_file_lock);
2273 		free_dentry_path(page);
2274 		*ret_file = find_readable_file(cinode, 0);
2275 		return *ret_file ? 0 : -ENOENT;
2276 	}
2277 
2278 	spin_unlock(&tcon->open_file_lock);
2279 	free_dentry_path(page);
2280 	return -ENOENT;
2281 }
2282 
2283 void
cifs_writedata_release(struct kref * refcount)2284 cifs_writedata_release(struct kref *refcount)
2285 {
2286 	struct cifs_writedata *wdata = container_of(refcount,
2287 					struct cifs_writedata, refcount);
2288 #ifdef CONFIG_CIFS_SMB_DIRECT
2289 	if (wdata->mr) {
2290 		smbd_deregister_mr(wdata->mr);
2291 		wdata->mr = NULL;
2292 	}
2293 #endif
2294 
2295 	if (wdata->cfile)
2296 		cifsFileInfo_put(wdata->cfile);
2297 
2298 	kvfree(wdata->pages);
2299 	kfree(wdata);
2300 }
2301 
2302 /*
2303  * Write failed with a retryable error. Resend the write request. It's also
2304  * possible that the page was redirtied so re-clean the page.
2305  */
2306 static void
cifs_writev_requeue(struct cifs_writedata * wdata)2307 cifs_writev_requeue(struct cifs_writedata *wdata)
2308 {
2309 	int i, rc = 0;
2310 	struct inode *inode = d_inode(wdata->cfile->dentry);
2311 	struct TCP_Server_Info *server;
2312 	unsigned int rest_len;
2313 
2314 	server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2315 	i = 0;
2316 	rest_len = wdata->bytes;
2317 	do {
2318 		struct cifs_writedata *wdata2;
2319 		unsigned int j, nr_pages, wsize, tailsz, cur_len;
2320 
2321 		wsize = server->ops->wp_retry_size(inode);
2322 		if (wsize < rest_len) {
2323 			nr_pages = wsize / PAGE_SIZE;
2324 			if (!nr_pages) {
2325 				rc = -EOPNOTSUPP;
2326 				break;
2327 			}
2328 			cur_len = nr_pages * PAGE_SIZE;
2329 			tailsz = PAGE_SIZE;
2330 		} else {
2331 			nr_pages = DIV_ROUND_UP(rest_len, PAGE_SIZE);
2332 			cur_len = rest_len;
2333 			tailsz = rest_len - (nr_pages - 1) * PAGE_SIZE;
2334 		}
2335 
2336 		wdata2 = cifs_writedata_alloc(nr_pages, cifs_writev_complete);
2337 		if (!wdata2) {
2338 			rc = -ENOMEM;
2339 			break;
2340 		}
2341 
2342 		for (j = 0; j < nr_pages; j++) {
2343 			wdata2->pages[j] = wdata->pages[i + j];
2344 			lock_page(wdata2->pages[j]);
2345 			clear_page_dirty_for_io(wdata2->pages[j]);
2346 		}
2347 
2348 		wdata2->sync_mode = wdata->sync_mode;
2349 		wdata2->nr_pages = nr_pages;
2350 		wdata2->offset = page_offset(wdata2->pages[0]);
2351 		wdata2->pagesz = PAGE_SIZE;
2352 		wdata2->tailsz = tailsz;
2353 		wdata2->bytes = cur_len;
2354 
2355 		rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY,
2356 					    &wdata2->cfile);
2357 		if (!wdata2->cfile) {
2358 			cifs_dbg(VFS, "No writable handle to retry writepages rc=%d\n",
2359 				 rc);
2360 			if (!is_retryable_error(rc))
2361 				rc = -EBADF;
2362 		} else {
2363 			wdata2->pid = wdata2->cfile->pid;
2364 			rc = server->ops->async_writev(wdata2,
2365 						       cifs_writedata_release);
2366 		}
2367 
2368 		for (j = 0; j < nr_pages; j++) {
2369 			unlock_page(wdata2->pages[j]);
2370 			if (rc != 0 && !is_retryable_error(rc)) {
2371 				SetPageError(wdata2->pages[j]);
2372 				end_page_writeback(wdata2->pages[j]);
2373 				put_page(wdata2->pages[j]);
2374 			}
2375 		}
2376 
2377 		kref_put(&wdata2->refcount, cifs_writedata_release);
2378 		if (rc) {
2379 			if (is_retryable_error(rc))
2380 				continue;
2381 			i += nr_pages;
2382 			break;
2383 		}
2384 
2385 		rest_len -= cur_len;
2386 		i += nr_pages;
2387 	} while (i < wdata->nr_pages);
2388 
2389 	/* cleanup remaining pages from the original wdata */
2390 	for (; i < wdata->nr_pages; i++) {
2391 		SetPageError(wdata->pages[i]);
2392 		end_page_writeback(wdata->pages[i]);
2393 		put_page(wdata->pages[i]);
2394 	}
2395 
2396 	if (rc != 0 && !is_retryable_error(rc))
2397 		mapping_set_error(inode->i_mapping, rc);
2398 	kref_put(&wdata->refcount, cifs_writedata_release);
2399 }
2400 
2401 void
cifs_writev_complete(struct work_struct * work)2402 cifs_writev_complete(struct work_struct *work)
2403 {
2404 	struct cifs_writedata *wdata = container_of(work,
2405 						struct cifs_writedata, work);
2406 	struct inode *inode = d_inode(wdata->cfile->dentry);
2407 	int i = 0;
2408 
2409 	if (wdata->result == 0) {
2410 		spin_lock(&inode->i_lock);
2411 		cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2412 		spin_unlock(&inode->i_lock);
2413 		cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2414 					 wdata->bytes);
2415 	} else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2416 		return cifs_writev_requeue(wdata);
2417 
2418 	for (i = 0; i < wdata->nr_pages; i++) {
2419 		struct page *page = wdata->pages[i];
2420 
2421 		if (wdata->result == -EAGAIN)
2422 			__set_page_dirty_nobuffers(page);
2423 		else if (wdata->result < 0)
2424 			SetPageError(page);
2425 		end_page_writeback(page);
2426 		cifs_readpage_to_fscache(inode, page);
2427 		put_page(page);
2428 	}
2429 	if (wdata->result != -EAGAIN)
2430 		mapping_set_error(inode->i_mapping, wdata->result);
2431 	kref_put(&wdata->refcount, cifs_writedata_release);
2432 }
2433 
2434 struct cifs_writedata *
cifs_writedata_alloc(unsigned int nr_pages,work_func_t complete)2435 cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
2436 {
2437 	struct cifs_writedata *writedata = NULL;
2438 	struct page **pages =
2439 		kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS);
2440 	if (pages) {
2441 		writedata = cifs_writedata_direct_alloc(pages, complete);
2442 		if (!writedata)
2443 			kvfree(pages);
2444 	}
2445 
2446 	return writedata;
2447 }
2448 
2449 struct cifs_writedata *
cifs_writedata_direct_alloc(struct page ** pages,work_func_t complete)2450 cifs_writedata_direct_alloc(struct page **pages, work_func_t complete)
2451 {
2452 	struct cifs_writedata *wdata;
2453 
2454 	wdata = kzalloc(sizeof(*wdata), GFP_NOFS);
2455 	if (wdata != NULL) {
2456 		wdata->pages = pages;
2457 		kref_init(&wdata->refcount);
2458 		INIT_LIST_HEAD(&wdata->list);
2459 		init_completion(&wdata->done);
2460 		INIT_WORK(&wdata->work, complete);
2461 	}
2462 	return wdata;
2463 }
2464 
2465 
cifs_partialpagewrite(struct page * page,unsigned from,unsigned to)2466 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
2467 {
2468 	struct address_space *mapping = page->mapping;
2469 	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
2470 	char *write_data;
2471 	int rc = -EFAULT;
2472 	int bytes_written = 0;
2473 	struct inode *inode;
2474 	struct cifsFileInfo *open_file;
2475 
2476 	if (!mapping || !mapping->host)
2477 		return -EFAULT;
2478 
2479 	inode = page->mapping->host;
2480 
2481 	offset += (loff_t)from;
2482 	write_data = kmap(page);
2483 	write_data += from;
2484 
2485 	if ((to > PAGE_SIZE) || (from > to)) {
2486 		kunmap(page);
2487 		return -EIO;
2488 	}
2489 
2490 	/* racing with truncate? */
2491 	if (offset > mapping->host->i_size) {
2492 		kunmap(page);
2493 		return 0; /* don't care */
2494 	}
2495 
2496 	/* check to make sure that we are not extending the file */
2497 	if (mapping->host->i_size - offset < (loff_t)to)
2498 		to = (unsigned)(mapping->host->i_size - offset);
2499 
2500 	rc = cifs_get_writable_file(CIFS_I(mapping->host), FIND_WR_ANY,
2501 				    &open_file);
2502 	if (!rc) {
2503 		bytes_written = cifs_write(open_file, open_file->pid,
2504 					   write_data, to - from, &offset);
2505 		cifsFileInfo_put(open_file);
2506 		/* Does mm or vfs already set times? */
2507 		inode->i_atime = inode->i_mtime = current_time(inode);
2508 		if ((bytes_written > 0) && (offset))
2509 			rc = 0;
2510 		else if (bytes_written < 0)
2511 			rc = bytes_written;
2512 		else
2513 			rc = -EFAULT;
2514 	} else {
2515 		cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2516 		if (!is_retryable_error(rc))
2517 			rc = -EIO;
2518 	}
2519 
2520 	kunmap(page);
2521 	return rc;
2522 }
2523 
2524 static struct cifs_writedata *
wdata_alloc_and_fillpages(pgoff_t tofind,struct address_space * mapping,pgoff_t end,pgoff_t * index,unsigned int * found_pages)2525 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2526 			  pgoff_t end, pgoff_t *index,
2527 			  unsigned int *found_pages)
2528 {
2529 	struct cifs_writedata *wdata;
2530 
2531 	wdata = cifs_writedata_alloc((unsigned int)tofind,
2532 				     cifs_writev_complete);
2533 	if (!wdata)
2534 		return NULL;
2535 
2536 	*found_pages = find_get_pages_range_tag(mapping, index, end,
2537 				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2538 	return wdata;
2539 }
2540 
2541 static unsigned int
wdata_prepare_pages(struct cifs_writedata * wdata,unsigned int found_pages,struct address_space * mapping,struct writeback_control * wbc,pgoff_t end,pgoff_t * index,pgoff_t * next,bool * done)2542 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2543 		    struct address_space *mapping,
2544 		    struct writeback_control *wbc,
2545 		    pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2546 {
2547 	unsigned int nr_pages = 0, i;
2548 	struct page *page;
2549 
2550 	for (i = 0; i < found_pages; i++) {
2551 		page = wdata->pages[i];
2552 		/*
2553 		 * At this point we hold neither the i_pages lock nor the
2554 		 * page lock: the page may be truncated or invalidated
2555 		 * (changing page->mapping to NULL), or even swizzled
2556 		 * back from swapper_space to tmpfs file mapping
2557 		 */
2558 
2559 		if (nr_pages == 0)
2560 			lock_page(page);
2561 		else if (!trylock_page(page))
2562 			break;
2563 
2564 		if (unlikely(page->mapping != mapping)) {
2565 			unlock_page(page);
2566 			break;
2567 		}
2568 
2569 		if (!wbc->range_cyclic && page->index > end) {
2570 			*done = true;
2571 			unlock_page(page);
2572 			break;
2573 		}
2574 
2575 		if (*next && (page->index != *next)) {
2576 			/* Not next consecutive page */
2577 			unlock_page(page);
2578 			break;
2579 		}
2580 
2581 		if (wbc->sync_mode != WB_SYNC_NONE)
2582 			wait_on_page_writeback(page);
2583 
2584 		if (PageWriteback(page) ||
2585 				!clear_page_dirty_for_io(page)) {
2586 			unlock_page(page);
2587 			break;
2588 		}
2589 
2590 		/*
2591 		 * This actually clears the dirty bit in the radix tree.
2592 		 * See cifs_writepage() for more commentary.
2593 		 */
2594 		set_page_writeback(page);
2595 		if (page_offset(page) >= i_size_read(mapping->host)) {
2596 			*done = true;
2597 			unlock_page(page);
2598 			end_page_writeback(page);
2599 			break;
2600 		}
2601 
2602 		wdata->pages[i] = page;
2603 		*next = page->index + 1;
2604 		++nr_pages;
2605 	}
2606 
2607 	/* reset index to refind any pages skipped */
2608 	if (nr_pages == 0)
2609 		*index = wdata->pages[0]->index + 1;
2610 
2611 	/* put any pages we aren't going to use */
2612 	for (i = nr_pages; i < found_pages; i++) {
2613 		put_page(wdata->pages[i]);
2614 		wdata->pages[i] = NULL;
2615 	}
2616 
2617 	return nr_pages;
2618 }
2619 
2620 static int
wdata_send_pages(struct cifs_writedata * wdata,unsigned int nr_pages,struct address_space * mapping,struct writeback_control * wbc)2621 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2622 		 struct address_space *mapping, struct writeback_control *wbc)
2623 {
2624 	int rc;
2625 
2626 	wdata->sync_mode = wbc->sync_mode;
2627 	wdata->nr_pages = nr_pages;
2628 	wdata->offset = page_offset(wdata->pages[0]);
2629 	wdata->pagesz = PAGE_SIZE;
2630 	wdata->tailsz = min(i_size_read(mapping->host) -
2631 			page_offset(wdata->pages[nr_pages - 1]),
2632 			(loff_t)PAGE_SIZE);
2633 	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2634 	wdata->pid = wdata->cfile->pid;
2635 
2636 	rc = adjust_credits(wdata->server, &wdata->credits, wdata->bytes);
2637 	if (rc)
2638 		return rc;
2639 
2640 	if (wdata->cfile->invalidHandle)
2641 		rc = -EAGAIN;
2642 	else
2643 		rc = wdata->server->ops->async_writev(wdata,
2644 						      cifs_writedata_release);
2645 
2646 	return rc;
2647 }
2648 
cifs_writepages(struct address_space * mapping,struct writeback_control * wbc)2649 static int cifs_writepages(struct address_space *mapping,
2650 			   struct writeback_control *wbc)
2651 {
2652 	struct inode *inode = mapping->host;
2653 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2654 	struct TCP_Server_Info *server;
2655 	bool done = false, scanned = false, range_whole = false;
2656 	pgoff_t end, index;
2657 	struct cifs_writedata *wdata;
2658 	struct cifsFileInfo *cfile = NULL;
2659 	int rc = 0;
2660 	int saved_rc = 0;
2661 	unsigned int xid;
2662 
2663 	/*
2664 	 * If wsize is smaller than the page cache size, default to writing
2665 	 * one page at a time via cifs_writepage
2666 	 */
2667 	if (cifs_sb->ctx->wsize < PAGE_SIZE)
2668 		return generic_writepages(mapping, wbc);
2669 
2670 	xid = get_xid();
2671 	if (wbc->range_cyclic) {
2672 		index = mapping->writeback_index; /* Start from prev offset */
2673 		end = -1;
2674 	} else {
2675 		index = wbc->range_start >> PAGE_SHIFT;
2676 		end = wbc->range_end >> PAGE_SHIFT;
2677 		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2678 			range_whole = true;
2679 		scanned = true;
2680 	}
2681 	server = cifs_pick_channel(cifs_sb_master_tcon(cifs_sb)->ses);
2682 
2683 retry:
2684 	while (!done && index <= end) {
2685 		unsigned int i, nr_pages, found_pages, wsize;
2686 		pgoff_t next = 0, tofind, saved_index = index;
2687 		struct cifs_credits credits_on_stack;
2688 		struct cifs_credits *credits = &credits_on_stack;
2689 		int get_file_rc = 0;
2690 
2691 		if (cfile)
2692 			cifsFileInfo_put(cfile);
2693 
2694 		rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile);
2695 
2696 		/* in case of an error store it to return later */
2697 		if (rc)
2698 			get_file_rc = rc;
2699 
2700 		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
2701 						   &wsize, credits);
2702 		if (rc != 0) {
2703 			done = true;
2704 			break;
2705 		}
2706 
2707 		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2708 
2709 		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2710 						  &found_pages);
2711 		if (!wdata) {
2712 			rc = -ENOMEM;
2713 			done = true;
2714 			add_credits_and_wake_if(server, credits, 0);
2715 			break;
2716 		}
2717 
2718 		if (found_pages == 0) {
2719 			kref_put(&wdata->refcount, cifs_writedata_release);
2720 			add_credits_and_wake_if(server, credits, 0);
2721 			break;
2722 		}
2723 
2724 		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2725 					       end, &index, &next, &done);
2726 
2727 		/* nothing to write? */
2728 		if (nr_pages == 0) {
2729 			kref_put(&wdata->refcount, cifs_writedata_release);
2730 			add_credits_and_wake_if(server, credits, 0);
2731 			continue;
2732 		}
2733 
2734 		wdata->credits = credits_on_stack;
2735 		wdata->cfile = cfile;
2736 		wdata->server = server;
2737 		cfile = NULL;
2738 
2739 		if (!wdata->cfile) {
2740 			cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2741 				 get_file_rc);
2742 			if (is_retryable_error(get_file_rc))
2743 				rc = get_file_rc;
2744 			else
2745 				rc = -EBADF;
2746 		} else
2747 			rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2748 
2749 		for (i = 0; i < nr_pages; ++i)
2750 			unlock_page(wdata->pages[i]);
2751 
2752 		/* send failure -- clean up the mess */
2753 		if (rc != 0) {
2754 			add_credits_and_wake_if(server, &wdata->credits, 0);
2755 			for (i = 0; i < nr_pages; ++i) {
2756 				if (is_retryable_error(rc))
2757 					redirty_page_for_writepage(wbc,
2758 							   wdata->pages[i]);
2759 				else
2760 					SetPageError(wdata->pages[i]);
2761 				end_page_writeback(wdata->pages[i]);
2762 				put_page(wdata->pages[i]);
2763 			}
2764 			if (!is_retryable_error(rc))
2765 				mapping_set_error(mapping, rc);
2766 		}
2767 		kref_put(&wdata->refcount, cifs_writedata_release);
2768 
2769 		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2770 			index = saved_index;
2771 			continue;
2772 		}
2773 
2774 		/* Return immediately if we received a signal during writing */
2775 		if (is_interrupt_error(rc)) {
2776 			done = true;
2777 			break;
2778 		}
2779 
2780 		if (rc != 0 && saved_rc == 0)
2781 			saved_rc = rc;
2782 
2783 		wbc->nr_to_write -= nr_pages;
2784 		if (wbc->nr_to_write <= 0)
2785 			done = true;
2786 
2787 		index = next;
2788 	}
2789 
2790 	if (!scanned && !done) {
2791 		/*
2792 		 * We hit the last page and there is more work to be done: wrap
2793 		 * back to the start of the file
2794 		 */
2795 		scanned = true;
2796 		index = 0;
2797 		goto retry;
2798 	}
2799 
2800 	if (saved_rc != 0)
2801 		rc = saved_rc;
2802 
2803 	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2804 		mapping->writeback_index = index;
2805 
2806 	if (cfile)
2807 		cifsFileInfo_put(cfile);
2808 	free_xid(xid);
2809 	/* Indication to update ctime and mtime as close is deferred */
2810 	set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2811 	return rc;
2812 }
2813 
2814 static int
cifs_writepage_locked(struct page * page,struct writeback_control * wbc)2815 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2816 {
2817 	int rc;
2818 	unsigned int xid;
2819 
2820 	xid = get_xid();
2821 /* BB add check for wbc flags */
2822 	get_page(page);
2823 	if (!PageUptodate(page))
2824 		cifs_dbg(FYI, "ppw - page not up to date\n");
2825 
2826 	/*
2827 	 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2828 	 *
2829 	 * A writepage() implementation always needs to do either this,
2830 	 * or re-dirty the page with "redirty_page_for_writepage()" in
2831 	 * the case of a failure.
2832 	 *
2833 	 * Just unlocking the page will cause the radix tree tag-bits
2834 	 * to fail to update with the state of the page correctly.
2835 	 */
2836 	set_page_writeback(page);
2837 retry_write:
2838 	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2839 	if (is_retryable_error(rc)) {
2840 		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2841 			goto retry_write;
2842 		redirty_page_for_writepage(wbc, page);
2843 	} else if (rc != 0) {
2844 		SetPageError(page);
2845 		mapping_set_error(page->mapping, rc);
2846 	} else {
2847 		SetPageUptodate(page);
2848 	}
2849 	end_page_writeback(page);
2850 	put_page(page);
2851 	free_xid(xid);
2852 	return rc;
2853 }
2854 
cifs_writepage(struct page * page,struct writeback_control * wbc)2855 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2856 {
2857 	int rc = cifs_writepage_locked(page, wbc);
2858 	unlock_page(page);
2859 	return rc;
2860 }
2861 
cifs_write_end(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,unsigned copied,struct page * page,void * fsdata)2862 static int cifs_write_end(struct file *file, struct address_space *mapping,
2863 			loff_t pos, unsigned len, unsigned copied,
2864 			struct page *page, void *fsdata)
2865 {
2866 	int rc;
2867 	struct inode *inode = mapping->host;
2868 	struct cifsFileInfo *cfile = file->private_data;
2869 	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2870 	__u32 pid;
2871 
2872 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2873 		pid = cfile->pid;
2874 	else
2875 		pid = current->tgid;
2876 
2877 	cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2878 		 page, pos, copied);
2879 
2880 	if (PageChecked(page)) {
2881 		if (copied == len)
2882 			SetPageUptodate(page);
2883 		ClearPageChecked(page);
2884 	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
2885 		SetPageUptodate(page);
2886 
2887 	if (!PageUptodate(page)) {
2888 		char *page_data;
2889 		unsigned offset = pos & (PAGE_SIZE - 1);
2890 		unsigned int xid;
2891 
2892 		xid = get_xid();
2893 		/* this is probably better than directly calling
2894 		   partialpage_write since in this function the file handle is
2895 		   known which we might as well	leverage */
2896 		/* BB check if anything else missing out of ppw
2897 		   such as updating last write time */
2898 		page_data = kmap(page);
2899 		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2900 		/* if (rc < 0) should we set writebehind rc? */
2901 		kunmap(page);
2902 
2903 		free_xid(xid);
2904 	} else {
2905 		rc = copied;
2906 		pos += copied;
2907 		set_page_dirty(page);
2908 	}
2909 
2910 	if (rc > 0) {
2911 		spin_lock(&inode->i_lock);
2912 		if (pos > inode->i_size) {
2913 			i_size_write(inode, pos);
2914 			inode->i_blocks = (512 - 1 + pos) >> 9;
2915 		}
2916 		spin_unlock(&inode->i_lock);
2917 	}
2918 
2919 	unlock_page(page);
2920 	put_page(page);
2921 	/* Indication to update ctime and mtime as close is deferred */
2922 	set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2923 
2924 	return rc;
2925 }
2926 
cifs_strict_fsync(struct file * file,loff_t start,loff_t end,int datasync)2927 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2928 		      int datasync)
2929 {
2930 	unsigned int xid;
2931 	int rc = 0;
2932 	struct cifs_tcon *tcon;
2933 	struct TCP_Server_Info *server;
2934 	struct cifsFileInfo *smbfile = file->private_data;
2935 	struct inode *inode = file_inode(file);
2936 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2937 
2938 	rc = file_write_and_wait_range(file, start, end);
2939 	if (rc) {
2940 		trace_cifs_fsync_err(inode->i_ino, rc);
2941 		return rc;
2942 	}
2943 
2944 	xid = get_xid();
2945 
2946 	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2947 		 file, datasync);
2948 
2949 	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2950 		rc = cifs_zap_mapping(inode);
2951 		if (rc) {
2952 			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2953 			rc = 0; /* don't care about it in fsync */
2954 		}
2955 	}
2956 
2957 	tcon = tlink_tcon(smbfile->tlink);
2958 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2959 		server = tcon->ses->server;
2960 		if (server->ops->flush == NULL) {
2961 			rc = -ENOSYS;
2962 			goto strict_fsync_exit;
2963 		}
2964 
2965 		if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2966 			smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2967 			if (smbfile) {
2968 				rc = server->ops->flush(xid, tcon, &smbfile->fid);
2969 				cifsFileInfo_put(smbfile);
2970 			} else
2971 				cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2972 		} else
2973 			rc = server->ops->flush(xid, tcon, &smbfile->fid);
2974 	}
2975 
2976 strict_fsync_exit:
2977 	free_xid(xid);
2978 	return rc;
2979 }
2980 
cifs_fsync(struct file * file,loff_t start,loff_t end,int datasync)2981 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2982 {
2983 	unsigned int xid;
2984 	int rc = 0;
2985 	struct cifs_tcon *tcon;
2986 	struct TCP_Server_Info *server;
2987 	struct cifsFileInfo *smbfile = file->private_data;
2988 	struct inode *inode = file_inode(file);
2989 	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2990 
2991 	rc = file_write_and_wait_range(file, start, end);
2992 	if (rc) {
2993 		trace_cifs_fsync_err(file_inode(file)->i_ino, rc);
2994 		return rc;
2995 	}
2996 
2997 	xid = get_xid();
2998 
2999 	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
3000 		 file, datasync);
3001 
3002 	tcon = tlink_tcon(smbfile->tlink);
3003 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
3004 		server = tcon->ses->server;
3005 		if (server->ops->flush == NULL) {
3006 			rc = -ENOSYS;
3007 			goto fsync_exit;
3008 		}
3009 
3010 		if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
3011 			smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
3012 			if (smbfile) {
3013 				rc = server->ops->flush(xid, tcon, &smbfile->fid);
3014 				cifsFileInfo_put(smbfile);
3015 			} else
3016 				cifs_dbg(FYI, "ignore fsync for file not open for write\n");
3017 		} else
3018 			rc = server->ops->flush(xid, tcon, &smbfile->fid);
3019 	}
3020 
3021 fsync_exit:
3022 	free_xid(xid);
3023 	return rc;
3024 }
3025 
3026 /*
3027  * As file closes, flush all cached write data for this inode checking
3028  * for write behind errors.
3029  */
cifs_flush(struct file * file,fl_owner_t id)3030 int cifs_flush(struct file *file, fl_owner_t id)
3031 {
3032 	struct inode *inode = file_inode(file);
3033 	int rc = 0;
3034 
3035 	if (file->f_mode & FMODE_WRITE)
3036 		rc = filemap_write_and_wait(inode->i_mapping);
3037 
3038 	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
3039 	if (rc) {
3040 		/* get more nuanced writeback errors */
3041 		rc = filemap_check_wb_err(file->f_mapping, 0);
3042 		trace_cifs_flush_err(inode->i_ino, rc);
3043 	}
3044 	return rc;
3045 }
3046 
3047 static int
cifs_write_allocate_pages(struct page ** pages,unsigned long num_pages)3048 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
3049 {
3050 	int rc = 0;
3051 	unsigned long i;
3052 
3053 	for (i = 0; i < num_pages; i++) {
3054 		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3055 		if (!pages[i]) {
3056 			/*
3057 			 * save number of pages we have already allocated and
3058 			 * return with ENOMEM error
3059 			 */
3060 			num_pages = i;
3061 			rc = -ENOMEM;
3062 			break;
3063 		}
3064 	}
3065 
3066 	if (rc) {
3067 		for (i = 0; i < num_pages; i++)
3068 			put_page(pages[i]);
3069 	}
3070 	return rc;
3071 }
3072 
3073 static inline
get_numpages(const size_t wsize,const size_t len,size_t * cur_len)3074 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
3075 {
3076 	size_t num_pages;
3077 	size_t clen;
3078 
3079 	clen = min_t(const size_t, len, wsize);
3080 	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
3081 
3082 	if (cur_len)
3083 		*cur_len = clen;
3084 
3085 	return num_pages;
3086 }
3087 
3088 static void
cifs_uncached_writedata_release(struct kref * refcount)3089 cifs_uncached_writedata_release(struct kref *refcount)
3090 {
3091 	int i;
3092 	struct cifs_writedata *wdata = container_of(refcount,
3093 					struct cifs_writedata, refcount);
3094 
3095 	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
3096 	for (i = 0; i < wdata->nr_pages; i++)
3097 		put_page(wdata->pages[i]);
3098 	cifs_writedata_release(refcount);
3099 }
3100 
3101 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
3102 
3103 static void
cifs_uncached_writev_complete(struct work_struct * work)3104 cifs_uncached_writev_complete(struct work_struct *work)
3105 {
3106 	struct cifs_writedata *wdata = container_of(work,
3107 					struct cifs_writedata, work);
3108 	struct inode *inode = d_inode(wdata->cfile->dentry);
3109 	struct cifsInodeInfo *cifsi = CIFS_I(inode);
3110 
3111 	spin_lock(&inode->i_lock);
3112 	cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
3113 	if (cifsi->server_eof > inode->i_size)
3114 		i_size_write(inode, cifsi->server_eof);
3115 	spin_unlock(&inode->i_lock);
3116 
3117 	complete(&wdata->done);
3118 	collect_uncached_write_data(wdata->ctx);
3119 	/* the below call can possibly free the last ref to aio ctx */
3120 	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3121 }
3122 
3123 static int
wdata_fill_from_iovec(struct cifs_writedata * wdata,struct iov_iter * from,size_t * len,unsigned long * num_pages)3124 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
3125 		      size_t *len, unsigned long *num_pages)
3126 {
3127 	size_t save_len, copied, bytes, cur_len = *len;
3128 	unsigned long i, nr_pages = *num_pages;
3129 
3130 	save_len = cur_len;
3131 	for (i = 0; i < nr_pages; i++) {
3132 		bytes = min_t(const size_t, cur_len, PAGE_SIZE);
3133 		copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
3134 		cur_len -= copied;
3135 		/*
3136 		 * If we didn't copy as much as we expected, then that
3137 		 * may mean we trod into an unmapped area. Stop copying
3138 		 * at that point. On the next pass through the big
3139 		 * loop, we'll likely end up getting a zero-length
3140 		 * write and bailing out of it.
3141 		 */
3142 		if (copied < bytes)
3143 			break;
3144 	}
3145 	cur_len = save_len - cur_len;
3146 	*len = cur_len;
3147 
3148 	/*
3149 	 * If we have no data to send, then that probably means that
3150 	 * the copy above failed altogether. That's most likely because
3151 	 * the address in the iovec was bogus. Return -EFAULT and let
3152 	 * the caller free anything we allocated and bail out.
3153 	 */
3154 	if (!cur_len)
3155 		return -EFAULT;
3156 
3157 	/*
3158 	 * i + 1 now represents the number of pages we actually used in
3159 	 * the copy phase above.
3160 	 */
3161 	*num_pages = i + 1;
3162 	return 0;
3163 }
3164 
3165 static int
cifs_resend_wdata(struct cifs_writedata * wdata,struct list_head * wdata_list,struct cifs_aio_ctx * ctx)3166 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
3167 	struct cifs_aio_ctx *ctx)
3168 {
3169 	unsigned int wsize;
3170 	struct cifs_credits credits;
3171 	int rc;
3172 	struct TCP_Server_Info *server = wdata->server;
3173 
3174 	do {
3175 		if (wdata->cfile->invalidHandle) {
3176 			rc = cifs_reopen_file(wdata->cfile, false);
3177 			if (rc == -EAGAIN)
3178 				continue;
3179 			else if (rc)
3180 				break;
3181 		}
3182 
3183 
3184 		/*
3185 		 * Wait for credits to resend this wdata.
3186 		 * Note: we are attempting to resend the whole wdata not in
3187 		 * segments
3188 		 */
3189 		do {
3190 			rc = server->ops->wait_mtu_credits(server, wdata->bytes,
3191 						&wsize, &credits);
3192 			if (rc)
3193 				goto fail;
3194 
3195 			if (wsize < wdata->bytes) {
3196 				add_credits_and_wake_if(server, &credits, 0);
3197 				msleep(1000);
3198 			}
3199 		} while (wsize < wdata->bytes);
3200 		wdata->credits = credits;
3201 
3202 		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3203 
3204 		if (!rc) {
3205 			if (wdata->cfile->invalidHandle)
3206 				rc = -EAGAIN;
3207 			else {
3208 #ifdef CONFIG_CIFS_SMB_DIRECT
3209 				if (wdata->mr) {
3210 					wdata->mr->need_invalidate = true;
3211 					smbd_deregister_mr(wdata->mr);
3212 					wdata->mr = NULL;
3213 				}
3214 #endif
3215 				rc = server->ops->async_writev(wdata,
3216 					cifs_uncached_writedata_release);
3217 			}
3218 		}
3219 
3220 		/* If the write was successfully sent, we are done */
3221 		if (!rc) {
3222 			list_add_tail(&wdata->list, wdata_list);
3223 			return 0;
3224 		}
3225 
3226 		/* Roll back credits and retry if needed */
3227 		add_credits_and_wake_if(server, &wdata->credits, 0);
3228 	} while (rc == -EAGAIN);
3229 
3230 fail:
3231 	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3232 	return rc;
3233 }
3234 
3235 static int
cifs_write_from_iter(loff_t offset,size_t len,struct iov_iter * from,struct cifsFileInfo * open_file,struct cifs_sb_info * cifs_sb,struct list_head * wdata_list,struct cifs_aio_ctx * ctx)3236 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
3237 		     struct cifsFileInfo *open_file,
3238 		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
3239 		     struct cifs_aio_ctx *ctx)
3240 {
3241 	int rc = 0;
3242 	size_t cur_len;
3243 	unsigned long nr_pages, num_pages, i;
3244 	struct cifs_writedata *wdata;
3245 	struct iov_iter saved_from = *from;
3246 	loff_t saved_offset = offset;
3247 	pid_t pid;
3248 	struct TCP_Server_Info *server;
3249 	struct page **pagevec;
3250 	size_t start;
3251 	unsigned int xid;
3252 
3253 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3254 		pid = open_file->pid;
3255 	else
3256 		pid = current->tgid;
3257 
3258 	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3259 	xid = get_xid();
3260 
3261 	do {
3262 		unsigned int wsize;
3263 		struct cifs_credits credits_on_stack;
3264 		struct cifs_credits *credits = &credits_on_stack;
3265 
3266 		if (open_file->invalidHandle) {
3267 			rc = cifs_reopen_file(open_file, false);
3268 			if (rc == -EAGAIN)
3269 				continue;
3270 			else if (rc)
3271 				break;
3272 		}
3273 
3274 		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
3275 						   &wsize, credits);
3276 		if (rc)
3277 			break;
3278 
3279 		cur_len = min_t(const size_t, len, wsize);
3280 
3281 		if (ctx->direct_io) {
3282 			ssize_t result;
3283 
3284 			result = iov_iter_get_pages_alloc2(
3285 				from, &pagevec, cur_len, &start);
3286 			if (result < 0) {
3287 				cifs_dbg(VFS,
3288 					 "direct_writev couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
3289 					 result, iov_iter_type(from),
3290 					 from->iov_offset, from->count);
3291 				dump_stack();
3292 
3293 				rc = result;
3294 				add_credits_and_wake_if(server, credits, 0);
3295 				break;
3296 			}
3297 			cur_len = (size_t)result;
3298 
3299 			nr_pages =
3300 				(cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
3301 
3302 			wdata = cifs_writedata_direct_alloc(pagevec,
3303 					     cifs_uncached_writev_complete);
3304 			if (!wdata) {
3305 				rc = -ENOMEM;
3306 				for (i = 0; i < nr_pages; i++)
3307 					put_page(pagevec[i]);
3308 				kvfree(pagevec);
3309 				add_credits_and_wake_if(server, credits, 0);
3310 				break;
3311 			}
3312 
3313 
3314 			wdata->page_offset = start;
3315 			wdata->tailsz =
3316 				nr_pages > 1 ?
3317 					cur_len - (PAGE_SIZE - start) -
3318 					(nr_pages - 2) * PAGE_SIZE :
3319 					cur_len;
3320 		} else {
3321 			nr_pages = get_numpages(wsize, len, &cur_len);
3322 			wdata = cifs_writedata_alloc(nr_pages,
3323 					     cifs_uncached_writev_complete);
3324 			if (!wdata) {
3325 				rc = -ENOMEM;
3326 				add_credits_and_wake_if(server, credits, 0);
3327 				break;
3328 			}
3329 
3330 			rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
3331 			if (rc) {
3332 				kvfree(wdata->pages);
3333 				kfree(wdata);
3334 				add_credits_and_wake_if(server, credits, 0);
3335 				break;
3336 			}
3337 
3338 			num_pages = nr_pages;
3339 			rc = wdata_fill_from_iovec(
3340 				wdata, from, &cur_len, &num_pages);
3341 			if (rc) {
3342 				for (i = 0; i < nr_pages; i++)
3343 					put_page(wdata->pages[i]);
3344 				kvfree(wdata->pages);
3345 				kfree(wdata);
3346 				add_credits_and_wake_if(server, credits, 0);
3347 				break;
3348 			}
3349 
3350 			/*
3351 			 * Bring nr_pages down to the number of pages we
3352 			 * actually used, and free any pages that we didn't use.
3353 			 */
3354 			for ( ; nr_pages > num_pages; nr_pages--)
3355 				put_page(wdata->pages[nr_pages - 1]);
3356 
3357 			wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
3358 		}
3359 
3360 		wdata->sync_mode = WB_SYNC_ALL;
3361 		wdata->nr_pages = nr_pages;
3362 		wdata->offset = (__u64)offset;
3363 		wdata->cfile = cifsFileInfo_get(open_file);
3364 		wdata->server = server;
3365 		wdata->pid = pid;
3366 		wdata->bytes = cur_len;
3367 		wdata->pagesz = PAGE_SIZE;
3368 		wdata->credits = credits_on_stack;
3369 		wdata->ctx = ctx;
3370 		kref_get(&ctx->refcount);
3371 
3372 		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3373 
3374 		if (!rc) {
3375 			if (wdata->cfile->invalidHandle)
3376 				rc = -EAGAIN;
3377 			else
3378 				rc = server->ops->async_writev(wdata,
3379 					cifs_uncached_writedata_release);
3380 		}
3381 
3382 		if (rc) {
3383 			add_credits_and_wake_if(server, &wdata->credits, 0);
3384 			kref_put(&wdata->refcount,
3385 				 cifs_uncached_writedata_release);
3386 			if (rc == -EAGAIN) {
3387 				*from = saved_from;
3388 				iov_iter_advance(from, offset - saved_offset);
3389 				continue;
3390 			}
3391 			break;
3392 		}
3393 
3394 		list_add_tail(&wdata->list, wdata_list);
3395 		offset += cur_len;
3396 		len -= cur_len;
3397 	} while (len > 0);
3398 
3399 	free_xid(xid);
3400 	return rc;
3401 }
3402 
collect_uncached_write_data(struct cifs_aio_ctx * ctx)3403 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
3404 {
3405 	struct cifs_writedata *wdata, *tmp;
3406 	struct cifs_tcon *tcon;
3407 	struct cifs_sb_info *cifs_sb;
3408 	struct dentry *dentry = ctx->cfile->dentry;
3409 	ssize_t rc;
3410 
3411 	tcon = tlink_tcon(ctx->cfile->tlink);
3412 	cifs_sb = CIFS_SB(dentry->d_sb);
3413 
3414 	mutex_lock(&ctx->aio_mutex);
3415 
3416 	if (list_empty(&ctx->list)) {
3417 		mutex_unlock(&ctx->aio_mutex);
3418 		return;
3419 	}
3420 
3421 	rc = ctx->rc;
3422 	/*
3423 	 * Wait for and collect replies for any successful sends in order of
3424 	 * increasing offset. Once an error is hit, then return without waiting
3425 	 * for any more replies.
3426 	 */
3427 restart_loop:
3428 	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
3429 		if (!rc) {
3430 			if (!try_wait_for_completion(&wdata->done)) {
3431 				mutex_unlock(&ctx->aio_mutex);
3432 				return;
3433 			}
3434 
3435 			if (wdata->result)
3436 				rc = wdata->result;
3437 			else
3438 				ctx->total_len += wdata->bytes;
3439 
3440 			/* resend call if it's a retryable error */
3441 			if (rc == -EAGAIN) {
3442 				struct list_head tmp_list;
3443 				struct iov_iter tmp_from = ctx->iter;
3444 
3445 				INIT_LIST_HEAD(&tmp_list);
3446 				list_del_init(&wdata->list);
3447 
3448 				if (ctx->direct_io)
3449 					rc = cifs_resend_wdata(
3450 						wdata, &tmp_list, ctx);
3451 				else {
3452 					iov_iter_advance(&tmp_from,
3453 						 wdata->offset - ctx->pos);
3454 
3455 					rc = cifs_write_from_iter(wdata->offset,
3456 						wdata->bytes, &tmp_from,
3457 						ctx->cfile, cifs_sb, &tmp_list,
3458 						ctx);
3459 
3460 					kref_put(&wdata->refcount,
3461 						cifs_uncached_writedata_release);
3462 				}
3463 
3464 				list_splice(&tmp_list, &ctx->list);
3465 				goto restart_loop;
3466 			}
3467 		}
3468 		list_del_init(&wdata->list);
3469 		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3470 	}
3471 
3472 	cifs_stats_bytes_written(tcon, ctx->total_len);
3473 	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3474 
3475 	ctx->rc = (rc == 0) ? ctx->total_len : rc;
3476 
3477 	mutex_unlock(&ctx->aio_mutex);
3478 
3479 	if (ctx->iocb && ctx->iocb->ki_complete)
3480 		ctx->iocb->ki_complete(ctx->iocb, ctx->rc);
3481 	else
3482 		complete(&ctx->done);
3483 }
3484 
__cifs_writev(struct kiocb * iocb,struct iov_iter * from,bool direct)3485 static ssize_t __cifs_writev(
3486 	struct kiocb *iocb, struct iov_iter *from, bool direct)
3487 {
3488 	struct file *file = iocb->ki_filp;
3489 	ssize_t total_written = 0;
3490 	struct cifsFileInfo *cfile;
3491 	struct cifs_tcon *tcon;
3492 	struct cifs_sb_info *cifs_sb;
3493 	struct cifs_aio_ctx *ctx;
3494 	struct iov_iter saved_from = *from;
3495 	size_t len = iov_iter_count(from);
3496 	int rc;
3497 
3498 	/*
3499 	 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3500 	 * In this case, fall back to non-direct write function.
3501 	 * this could be improved by getting pages directly in ITER_KVEC
3502 	 */
3503 	if (direct && iov_iter_is_kvec(from)) {
3504 		cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3505 		direct = false;
3506 	}
3507 
3508 	rc = generic_write_checks(iocb, from);
3509 	if (rc <= 0)
3510 		return rc;
3511 
3512 	cifs_sb = CIFS_FILE_SB(file);
3513 	cfile = file->private_data;
3514 	tcon = tlink_tcon(cfile->tlink);
3515 
3516 	if (!tcon->ses->server->ops->async_writev)
3517 		return -ENOSYS;
3518 
3519 	ctx = cifs_aio_ctx_alloc();
3520 	if (!ctx)
3521 		return -ENOMEM;
3522 
3523 	ctx->cfile = cifsFileInfo_get(cfile);
3524 
3525 	if (!is_sync_kiocb(iocb))
3526 		ctx->iocb = iocb;
3527 
3528 	ctx->pos = iocb->ki_pos;
3529 
3530 	if (direct) {
3531 		ctx->direct_io = true;
3532 		ctx->iter = *from;
3533 		ctx->len = len;
3534 	} else {
3535 		rc = setup_aio_ctx_iter(ctx, from, WRITE);
3536 		if (rc) {
3537 			kref_put(&ctx->refcount, cifs_aio_ctx_release);
3538 			return rc;
3539 		}
3540 	}
3541 
3542 	/* grab a lock here due to read response handlers can access ctx */
3543 	mutex_lock(&ctx->aio_mutex);
3544 
3545 	rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3546 				  cfile, cifs_sb, &ctx->list, ctx);
3547 
3548 	/*
3549 	 * If at least one write was successfully sent, then discard any rc
3550 	 * value from the later writes. If the other write succeeds, then
3551 	 * we'll end up returning whatever was written. If it fails, then
3552 	 * we'll get a new rc value from that.
3553 	 */
3554 	if (!list_empty(&ctx->list))
3555 		rc = 0;
3556 
3557 	mutex_unlock(&ctx->aio_mutex);
3558 
3559 	if (rc) {
3560 		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3561 		return rc;
3562 	}
3563 
3564 	if (!is_sync_kiocb(iocb)) {
3565 		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3566 		return -EIOCBQUEUED;
3567 	}
3568 
3569 	rc = wait_for_completion_killable(&ctx->done);
3570 	if (rc) {
3571 		mutex_lock(&ctx->aio_mutex);
3572 		ctx->rc = rc = -EINTR;
3573 		total_written = ctx->total_len;
3574 		mutex_unlock(&ctx->aio_mutex);
3575 	} else {
3576 		rc = ctx->rc;
3577 		total_written = ctx->total_len;
3578 	}
3579 
3580 	kref_put(&ctx->refcount, cifs_aio_ctx_release);
3581 
3582 	if (unlikely(!total_written))
3583 		return rc;
3584 
3585 	iocb->ki_pos += total_written;
3586 	return total_written;
3587 }
3588 
cifs_direct_writev(struct kiocb * iocb,struct iov_iter * from)3589 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3590 {
3591 	struct file *file = iocb->ki_filp;
3592 
3593 	cifs_revalidate_mapping(file->f_inode);
3594 	return __cifs_writev(iocb, from, true);
3595 }
3596 
cifs_user_writev(struct kiocb * iocb,struct iov_iter * from)3597 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3598 {
3599 	return __cifs_writev(iocb, from, false);
3600 }
3601 
3602 static ssize_t
cifs_writev(struct kiocb * iocb,struct iov_iter * from)3603 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3604 {
3605 	struct file *file = iocb->ki_filp;
3606 	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3607 	struct inode *inode = file->f_mapping->host;
3608 	struct cifsInodeInfo *cinode = CIFS_I(inode);
3609 	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3610 	ssize_t rc;
3611 
3612 	inode_lock(inode);
3613 	/*
3614 	 * We need to hold the sem to be sure nobody modifies lock list
3615 	 * with a brlock that prevents writing.
3616 	 */
3617 	down_read(&cinode->lock_sem);
3618 
3619 	rc = generic_write_checks(iocb, from);
3620 	if (rc <= 0)
3621 		goto out;
3622 
3623 	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3624 				     server->vals->exclusive_lock_type, 0,
3625 				     NULL, CIFS_WRITE_OP))
3626 		rc = __generic_file_write_iter(iocb, from);
3627 	else
3628 		rc = -EACCES;
3629 out:
3630 	up_read(&cinode->lock_sem);
3631 	inode_unlock(inode);
3632 
3633 	if (rc > 0)
3634 		rc = generic_write_sync(iocb, rc);
3635 	return rc;
3636 }
3637 
3638 ssize_t
cifs_strict_writev(struct kiocb * iocb,struct iov_iter * from)3639 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3640 {
3641 	struct inode *inode = file_inode(iocb->ki_filp);
3642 	struct cifsInodeInfo *cinode = CIFS_I(inode);
3643 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3644 	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3645 						iocb->ki_filp->private_data;
3646 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3647 	ssize_t written;
3648 
3649 	written = cifs_get_writer(cinode);
3650 	if (written)
3651 		return written;
3652 
3653 	if (CIFS_CACHE_WRITE(cinode)) {
3654 		if (cap_unix(tcon->ses) &&
3655 		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3656 		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3657 			written = generic_file_write_iter(iocb, from);
3658 			goto out;
3659 		}
3660 		written = cifs_writev(iocb, from);
3661 		goto out;
3662 	}
3663 	/*
3664 	 * For non-oplocked files in strict cache mode we need to write the data
3665 	 * to the server exactly from the pos to pos+len-1 rather than flush all
3666 	 * affected pages because it may cause a error with mandatory locks on
3667 	 * these pages but not on the region from pos to ppos+len-1.
3668 	 */
3669 	written = cifs_user_writev(iocb, from);
3670 	if (CIFS_CACHE_READ(cinode)) {
3671 		/*
3672 		 * We have read level caching and we have just sent a write
3673 		 * request to the server thus making data in the cache stale.
3674 		 * Zap the cache and set oplock/lease level to NONE to avoid
3675 		 * reading stale data from the cache. All subsequent read
3676 		 * operations will read new data from the server.
3677 		 */
3678 		cifs_zap_mapping(inode);
3679 		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3680 			 inode);
3681 		cinode->oplock = 0;
3682 	}
3683 out:
3684 	cifs_put_writer(cinode);
3685 	return written;
3686 }
3687 
3688 static struct cifs_readdata *
cifs_readdata_direct_alloc(struct page ** pages,work_func_t complete)3689 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3690 {
3691 	struct cifs_readdata *rdata;
3692 
3693 	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3694 	if (rdata != NULL) {
3695 		rdata->pages = pages;
3696 		kref_init(&rdata->refcount);
3697 		INIT_LIST_HEAD(&rdata->list);
3698 		init_completion(&rdata->done);
3699 		INIT_WORK(&rdata->work, complete);
3700 	}
3701 
3702 	return rdata;
3703 }
3704 
3705 static struct cifs_readdata *
cifs_readdata_alloc(unsigned int nr_pages,work_func_t complete)3706 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3707 {
3708 	struct page **pages =
3709 		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3710 	struct cifs_readdata *ret = NULL;
3711 
3712 	if (pages) {
3713 		ret = cifs_readdata_direct_alloc(pages, complete);
3714 		if (!ret)
3715 			kfree(pages);
3716 	}
3717 
3718 	return ret;
3719 }
3720 
3721 void
cifs_readdata_release(struct kref * refcount)3722 cifs_readdata_release(struct kref *refcount)
3723 {
3724 	struct cifs_readdata *rdata = container_of(refcount,
3725 					struct cifs_readdata, refcount);
3726 #ifdef CONFIG_CIFS_SMB_DIRECT
3727 	if (rdata->mr) {
3728 		smbd_deregister_mr(rdata->mr);
3729 		rdata->mr = NULL;
3730 	}
3731 #endif
3732 	if (rdata->cfile)
3733 		cifsFileInfo_put(rdata->cfile);
3734 
3735 	kvfree(rdata->pages);
3736 	kfree(rdata);
3737 }
3738 
3739 static int
cifs_read_allocate_pages(struct cifs_readdata * rdata,unsigned int nr_pages)3740 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3741 {
3742 	int rc = 0;
3743 	struct page *page;
3744 	unsigned int i;
3745 
3746 	for (i = 0; i < nr_pages; i++) {
3747 		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3748 		if (!page) {
3749 			rc = -ENOMEM;
3750 			break;
3751 		}
3752 		rdata->pages[i] = page;
3753 	}
3754 
3755 	if (rc) {
3756 		unsigned int nr_page_failed = i;
3757 
3758 		for (i = 0; i < nr_page_failed; i++) {
3759 			put_page(rdata->pages[i]);
3760 			rdata->pages[i] = NULL;
3761 		}
3762 	}
3763 	return rc;
3764 }
3765 
3766 static void
cifs_uncached_readdata_release(struct kref * refcount)3767 cifs_uncached_readdata_release(struct kref *refcount)
3768 {
3769 	struct cifs_readdata *rdata = container_of(refcount,
3770 					struct cifs_readdata, refcount);
3771 	unsigned int i;
3772 
3773 	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3774 	for (i = 0; i < rdata->nr_pages; i++) {
3775 		put_page(rdata->pages[i]);
3776 	}
3777 	cifs_readdata_release(refcount);
3778 }
3779 
3780 /**
3781  * cifs_readdata_to_iov - copy data from pages in response to an iovec
3782  * @rdata:	the readdata response with list of pages holding data
3783  * @iter:	destination for our data
3784  *
3785  * This function copies data from a list of pages in a readdata response into
3786  * an array of iovecs. It will first calculate where the data should go
3787  * based on the info in the readdata and then copy the data into that spot.
3788  */
3789 static int
cifs_readdata_to_iov(struct cifs_readdata * rdata,struct iov_iter * iter)3790 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3791 {
3792 	size_t remaining = rdata->got_bytes;
3793 	unsigned int i;
3794 
3795 	for (i = 0; i < rdata->nr_pages; i++) {
3796 		struct page *page = rdata->pages[i];
3797 		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3798 		size_t written;
3799 
3800 		if (unlikely(iov_iter_is_pipe(iter))) {
3801 			void *addr = kmap_atomic(page);
3802 
3803 			written = copy_to_iter(addr, copy, iter);
3804 			kunmap_atomic(addr);
3805 		} else
3806 			written = copy_page_to_iter(page, 0, copy, iter);
3807 		remaining -= written;
3808 		if (written < copy && iov_iter_count(iter) > 0)
3809 			break;
3810 	}
3811 	return remaining ? -EFAULT : 0;
3812 }
3813 
3814 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3815 
3816 static void
cifs_uncached_readv_complete(struct work_struct * work)3817 cifs_uncached_readv_complete(struct work_struct *work)
3818 {
3819 	struct cifs_readdata *rdata = container_of(work,
3820 						struct cifs_readdata, work);
3821 
3822 	complete(&rdata->done);
3823 	collect_uncached_read_data(rdata->ctx);
3824 	/* the below call can possibly free the last ref to aio ctx */
3825 	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3826 }
3827 
3828 static int
uncached_fill_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,struct iov_iter * iter,unsigned int len)3829 uncached_fill_pages(struct TCP_Server_Info *server,
3830 		    struct cifs_readdata *rdata, struct iov_iter *iter,
3831 		    unsigned int len)
3832 {
3833 	int result = 0;
3834 	unsigned int i;
3835 	unsigned int nr_pages = rdata->nr_pages;
3836 	unsigned int page_offset = rdata->page_offset;
3837 
3838 	rdata->got_bytes = 0;
3839 	rdata->tailsz = PAGE_SIZE;
3840 	for (i = 0; i < nr_pages; i++) {
3841 		struct page *page = rdata->pages[i];
3842 		size_t n;
3843 		unsigned int segment_size = rdata->pagesz;
3844 
3845 		if (i == 0)
3846 			segment_size -= page_offset;
3847 		else
3848 			page_offset = 0;
3849 
3850 
3851 		if (len <= 0) {
3852 			/* no need to hold page hostage */
3853 			rdata->pages[i] = NULL;
3854 			rdata->nr_pages--;
3855 			put_page(page);
3856 			continue;
3857 		}
3858 
3859 		n = len;
3860 		if (len >= segment_size)
3861 			/* enough data to fill the page */
3862 			n = segment_size;
3863 		else
3864 			rdata->tailsz = len;
3865 		len -= n;
3866 
3867 		if (iter)
3868 			result = copy_page_from_iter(
3869 					page, page_offset, n, iter);
3870 #ifdef CONFIG_CIFS_SMB_DIRECT
3871 		else if (rdata->mr)
3872 			result = n;
3873 #endif
3874 		else
3875 			result = cifs_read_page_from_socket(
3876 					server, page, page_offset, n);
3877 		if (result < 0)
3878 			break;
3879 
3880 		rdata->got_bytes += result;
3881 	}
3882 
3883 	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3884 						rdata->got_bytes : result;
3885 }
3886 
3887 static int
cifs_uncached_read_into_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,unsigned int len)3888 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3889 			      struct cifs_readdata *rdata, unsigned int len)
3890 {
3891 	return uncached_fill_pages(server, rdata, NULL, len);
3892 }
3893 
3894 static int
cifs_uncached_copy_into_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,struct iov_iter * iter)3895 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3896 			      struct cifs_readdata *rdata,
3897 			      struct iov_iter *iter)
3898 {
3899 	return uncached_fill_pages(server, rdata, iter, iter->count);
3900 }
3901 
cifs_resend_rdata(struct cifs_readdata * rdata,struct list_head * rdata_list,struct cifs_aio_ctx * ctx)3902 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3903 			struct list_head *rdata_list,
3904 			struct cifs_aio_ctx *ctx)
3905 {
3906 	unsigned int rsize;
3907 	struct cifs_credits credits;
3908 	int rc;
3909 	struct TCP_Server_Info *server;
3910 
3911 	/* XXX: should we pick a new channel here? */
3912 	server = rdata->server;
3913 
3914 	do {
3915 		if (rdata->cfile->invalidHandle) {
3916 			rc = cifs_reopen_file(rdata->cfile, true);
3917 			if (rc == -EAGAIN)
3918 				continue;
3919 			else if (rc)
3920 				break;
3921 		}
3922 
3923 		/*
3924 		 * Wait for credits to resend this rdata.
3925 		 * Note: we are attempting to resend the whole rdata not in
3926 		 * segments
3927 		 */
3928 		do {
3929 			rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3930 						&rsize, &credits);
3931 
3932 			if (rc)
3933 				goto fail;
3934 
3935 			if (rsize < rdata->bytes) {
3936 				add_credits_and_wake_if(server, &credits, 0);
3937 				msleep(1000);
3938 			}
3939 		} while (rsize < rdata->bytes);
3940 		rdata->credits = credits;
3941 
3942 		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3943 		if (!rc) {
3944 			if (rdata->cfile->invalidHandle)
3945 				rc = -EAGAIN;
3946 			else {
3947 #ifdef CONFIG_CIFS_SMB_DIRECT
3948 				if (rdata->mr) {
3949 					rdata->mr->need_invalidate = true;
3950 					smbd_deregister_mr(rdata->mr);
3951 					rdata->mr = NULL;
3952 				}
3953 #endif
3954 				rc = server->ops->async_readv(rdata);
3955 			}
3956 		}
3957 
3958 		/* If the read was successfully sent, we are done */
3959 		if (!rc) {
3960 			/* Add to aio pending list */
3961 			list_add_tail(&rdata->list, rdata_list);
3962 			return 0;
3963 		}
3964 
3965 		/* Roll back credits and retry if needed */
3966 		add_credits_and_wake_if(server, &rdata->credits, 0);
3967 	} while (rc == -EAGAIN);
3968 
3969 fail:
3970 	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3971 	return rc;
3972 }
3973 
3974 static int
cifs_send_async_read(loff_t offset,size_t len,struct cifsFileInfo * open_file,struct cifs_sb_info * cifs_sb,struct list_head * rdata_list,struct cifs_aio_ctx * ctx)3975 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3976 		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3977 		     struct cifs_aio_ctx *ctx)
3978 {
3979 	struct cifs_readdata *rdata;
3980 	unsigned int npages, rsize;
3981 	struct cifs_credits credits_on_stack;
3982 	struct cifs_credits *credits = &credits_on_stack;
3983 	size_t cur_len;
3984 	int rc;
3985 	pid_t pid;
3986 	struct TCP_Server_Info *server;
3987 	struct page **pagevec;
3988 	size_t start;
3989 	struct iov_iter direct_iov = ctx->iter;
3990 
3991 	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3992 
3993 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3994 		pid = open_file->pid;
3995 	else
3996 		pid = current->tgid;
3997 
3998 	if (ctx->direct_io)
3999 		iov_iter_advance(&direct_iov, offset - ctx->pos);
4000 
4001 	do {
4002 		if (open_file->invalidHandle) {
4003 			rc = cifs_reopen_file(open_file, true);
4004 			if (rc == -EAGAIN)
4005 				continue;
4006 			else if (rc)
4007 				break;
4008 		}
4009 
4010 		if (cifs_sb->ctx->rsize == 0)
4011 			cifs_sb->ctx->rsize =
4012 				server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4013 							     cifs_sb->ctx);
4014 
4015 		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4016 						   &rsize, credits);
4017 		if (rc)
4018 			break;
4019 
4020 		cur_len = min_t(const size_t, len, rsize);
4021 
4022 		if (ctx->direct_io) {
4023 			ssize_t result;
4024 
4025 			result = iov_iter_get_pages_alloc2(
4026 					&direct_iov, &pagevec,
4027 					cur_len, &start);
4028 			if (result < 0) {
4029 				cifs_dbg(VFS,
4030 					 "Couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
4031 					 result, iov_iter_type(&direct_iov),
4032 					 direct_iov.iov_offset,
4033 					 direct_iov.count);
4034 				dump_stack();
4035 
4036 				rc = result;
4037 				add_credits_and_wake_if(server, credits, 0);
4038 				break;
4039 			}
4040 			cur_len = (size_t)result;
4041 
4042 			rdata = cifs_readdata_direct_alloc(
4043 					pagevec, cifs_uncached_readv_complete);
4044 			if (!rdata) {
4045 				add_credits_and_wake_if(server, credits, 0);
4046 				rc = -ENOMEM;
4047 				break;
4048 			}
4049 
4050 			npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
4051 			rdata->page_offset = start;
4052 			rdata->tailsz = npages > 1 ?
4053 				cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
4054 				cur_len;
4055 
4056 		} else {
4057 
4058 			npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
4059 			/* allocate a readdata struct */
4060 			rdata = cifs_readdata_alloc(npages,
4061 					    cifs_uncached_readv_complete);
4062 			if (!rdata) {
4063 				add_credits_and_wake_if(server, credits, 0);
4064 				rc = -ENOMEM;
4065 				break;
4066 			}
4067 
4068 			rc = cifs_read_allocate_pages(rdata, npages);
4069 			if (rc) {
4070 				kvfree(rdata->pages);
4071 				kfree(rdata);
4072 				add_credits_and_wake_if(server, credits, 0);
4073 				break;
4074 			}
4075 
4076 			rdata->tailsz = PAGE_SIZE;
4077 		}
4078 
4079 		rdata->server = server;
4080 		rdata->cfile = cifsFileInfo_get(open_file);
4081 		rdata->nr_pages = npages;
4082 		rdata->offset = offset;
4083 		rdata->bytes = cur_len;
4084 		rdata->pid = pid;
4085 		rdata->pagesz = PAGE_SIZE;
4086 		rdata->read_into_pages = cifs_uncached_read_into_pages;
4087 		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
4088 		rdata->credits = credits_on_stack;
4089 		rdata->ctx = ctx;
4090 		kref_get(&ctx->refcount);
4091 
4092 		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4093 
4094 		if (!rc) {
4095 			if (rdata->cfile->invalidHandle)
4096 				rc = -EAGAIN;
4097 			else
4098 				rc = server->ops->async_readv(rdata);
4099 		}
4100 
4101 		if (rc) {
4102 			add_credits_and_wake_if(server, &rdata->credits, 0);
4103 			kref_put(&rdata->refcount,
4104 				cifs_uncached_readdata_release);
4105 			if (rc == -EAGAIN) {
4106 				iov_iter_revert(&direct_iov, cur_len);
4107 				continue;
4108 			}
4109 			break;
4110 		}
4111 
4112 		list_add_tail(&rdata->list, rdata_list);
4113 		offset += cur_len;
4114 		len -= cur_len;
4115 	} while (len > 0);
4116 
4117 	return rc;
4118 }
4119 
4120 static void
collect_uncached_read_data(struct cifs_aio_ctx * ctx)4121 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
4122 {
4123 	struct cifs_readdata *rdata, *tmp;
4124 	struct iov_iter *to = &ctx->iter;
4125 	struct cifs_sb_info *cifs_sb;
4126 	int rc;
4127 
4128 	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
4129 
4130 	mutex_lock(&ctx->aio_mutex);
4131 
4132 	if (list_empty(&ctx->list)) {
4133 		mutex_unlock(&ctx->aio_mutex);
4134 		return;
4135 	}
4136 
4137 	rc = ctx->rc;
4138 	/* the loop below should proceed in the order of increasing offsets */
4139 again:
4140 	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
4141 		if (!rc) {
4142 			if (!try_wait_for_completion(&rdata->done)) {
4143 				mutex_unlock(&ctx->aio_mutex);
4144 				return;
4145 			}
4146 
4147 			if (rdata->result == -EAGAIN) {
4148 				/* resend call if it's a retryable error */
4149 				struct list_head tmp_list;
4150 				unsigned int got_bytes = rdata->got_bytes;
4151 
4152 				list_del_init(&rdata->list);
4153 				INIT_LIST_HEAD(&tmp_list);
4154 
4155 				/*
4156 				 * Got a part of data and then reconnect has
4157 				 * happened -- fill the buffer and continue
4158 				 * reading.
4159 				 */
4160 				if (got_bytes && got_bytes < rdata->bytes) {
4161 					rc = 0;
4162 					if (!ctx->direct_io)
4163 						rc = cifs_readdata_to_iov(rdata, to);
4164 					if (rc) {
4165 						kref_put(&rdata->refcount,
4166 							cifs_uncached_readdata_release);
4167 						continue;
4168 					}
4169 				}
4170 
4171 				if (ctx->direct_io) {
4172 					/*
4173 					 * Re-use rdata as this is a
4174 					 * direct I/O
4175 					 */
4176 					rc = cifs_resend_rdata(
4177 						rdata,
4178 						&tmp_list, ctx);
4179 				} else {
4180 					rc = cifs_send_async_read(
4181 						rdata->offset + got_bytes,
4182 						rdata->bytes - got_bytes,
4183 						rdata->cfile, cifs_sb,
4184 						&tmp_list, ctx);
4185 
4186 					kref_put(&rdata->refcount,
4187 						cifs_uncached_readdata_release);
4188 				}
4189 
4190 				list_splice(&tmp_list, &ctx->list);
4191 
4192 				goto again;
4193 			} else if (rdata->result)
4194 				rc = rdata->result;
4195 			else if (!ctx->direct_io)
4196 				rc = cifs_readdata_to_iov(rdata, to);
4197 
4198 			/* if there was a short read -- discard anything left */
4199 			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
4200 				rc = -ENODATA;
4201 
4202 			ctx->total_len += rdata->got_bytes;
4203 		}
4204 		list_del_init(&rdata->list);
4205 		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
4206 	}
4207 
4208 	if (!ctx->direct_io)
4209 		ctx->total_len = ctx->len - iov_iter_count(to);
4210 
4211 	/* mask nodata case */
4212 	if (rc == -ENODATA)
4213 		rc = 0;
4214 
4215 	ctx->rc = (rc == 0) ? (ssize_t)ctx->total_len : rc;
4216 
4217 	mutex_unlock(&ctx->aio_mutex);
4218 
4219 	if (ctx->iocb && ctx->iocb->ki_complete)
4220 		ctx->iocb->ki_complete(ctx->iocb, ctx->rc);
4221 	else
4222 		complete(&ctx->done);
4223 }
4224 
__cifs_readv(struct kiocb * iocb,struct iov_iter * to,bool direct)4225 static ssize_t __cifs_readv(
4226 	struct kiocb *iocb, struct iov_iter *to, bool direct)
4227 {
4228 	size_t len;
4229 	struct file *file = iocb->ki_filp;
4230 	struct cifs_sb_info *cifs_sb;
4231 	struct cifsFileInfo *cfile;
4232 	struct cifs_tcon *tcon;
4233 	ssize_t rc, total_read = 0;
4234 	loff_t offset = iocb->ki_pos;
4235 	struct cifs_aio_ctx *ctx;
4236 
4237 	/*
4238 	 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
4239 	 * fall back to data copy read path
4240 	 * this could be improved by getting pages directly in ITER_KVEC
4241 	 */
4242 	if (direct && iov_iter_is_kvec(to)) {
4243 		cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
4244 		direct = false;
4245 	}
4246 
4247 	len = iov_iter_count(to);
4248 	if (!len)
4249 		return 0;
4250 
4251 	cifs_sb = CIFS_FILE_SB(file);
4252 	cfile = file->private_data;
4253 	tcon = tlink_tcon(cfile->tlink);
4254 
4255 	if (!tcon->ses->server->ops->async_readv)
4256 		return -ENOSYS;
4257 
4258 	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4259 		cifs_dbg(FYI, "attempting read on write only file instance\n");
4260 
4261 	ctx = cifs_aio_ctx_alloc();
4262 	if (!ctx)
4263 		return -ENOMEM;
4264 
4265 	ctx->cfile = cifsFileInfo_get(cfile);
4266 
4267 	if (!is_sync_kiocb(iocb))
4268 		ctx->iocb = iocb;
4269 
4270 	if (user_backed_iter(to))
4271 		ctx->should_dirty = true;
4272 
4273 	if (direct) {
4274 		ctx->pos = offset;
4275 		ctx->direct_io = true;
4276 		ctx->iter = *to;
4277 		ctx->len = len;
4278 	} else {
4279 		rc = setup_aio_ctx_iter(ctx, to, READ);
4280 		if (rc) {
4281 			kref_put(&ctx->refcount, cifs_aio_ctx_release);
4282 			return rc;
4283 		}
4284 		len = ctx->len;
4285 	}
4286 
4287 	if (direct) {
4288 		rc = filemap_write_and_wait_range(file->f_inode->i_mapping,
4289 						  offset, offset + len - 1);
4290 		if (rc) {
4291 			kref_put(&ctx->refcount, cifs_aio_ctx_release);
4292 			return -EAGAIN;
4293 		}
4294 	}
4295 
4296 	/* grab a lock here due to read response handlers can access ctx */
4297 	mutex_lock(&ctx->aio_mutex);
4298 
4299 	rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
4300 
4301 	/* if at least one read request send succeeded, then reset rc */
4302 	if (!list_empty(&ctx->list))
4303 		rc = 0;
4304 
4305 	mutex_unlock(&ctx->aio_mutex);
4306 
4307 	if (rc) {
4308 		kref_put(&ctx->refcount, cifs_aio_ctx_release);
4309 		return rc;
4310 	}
4311 
4312 	if (!is_sync_kiocb(iocb)) {
4313 		kref_put(&ctx->refcount, cifs_aio_ctx_release);
4314 		return -EIOCBQUEUED;
4315 	}
4316 
4317 	rc = wait_for_completion_killable(&ctx->done);
4318 	if (rc) {
4319 		mutex_lock(&ctx->aio_mutex);
4320 		ctx->rc = rc = -EINTR;
4321 		total_read = ctx->total_len;
4322 		mutex_unlock(&ctx->aio_mutex);
4323 	} else {
4324 		rc = ctx->rc;
4325 		total_read = ctx->total_len;
4326 	}
4327 
4328 	kref_put(&ctx->refcount, cifs_aio_ctx_release);
4329 
4330 	if (total_read) {
4331 		iocb->ki_pos += total_read;
4332 		return total_read;
4333 	}
4334 	return rc;
4335 }
4336 
cifs_direct_readv(struct kiocb * iocb,struct iov_iter * to)4337 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
4338 {
4339 	return __cifs_readv(iocb, to, true);
4340 }
4341 
cifs_user_readv(struct kiocb * iocb,struct iov_iter * to)4342 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
4343 {
4344 	return __cifs_readv(iocb, to, false);
4345 }
4346 
4347 ssize_t
cifs_strict_readv(struct kiocb * iocb,struct iov_iter * to)4348 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
4349 {
4350 	struct inode *inode = file_inode(iocb->ki_filp);
4351 	struct cifsInodeInfo *cinode = CIFS_I(inode);
4352 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4353 	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
4354 						iocb->ki_filp->private_data;
4355 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4356 	int rc = -EACCES;
4357 
4358 	/*
4359 	 * In strict cache mode we need to read from the server all the time
4360 	 * if we don't have level II oplock because the server can delay mtime
4361 	 * change - so we can't make a decision about inode invalidating.
4362 	 * And we can also fail with pagereading if there are mandatory locks
4363 	 * on pages affected by this read but not on the region from pos to
4364 	 * pos+len-1.
4365 	 */
4366 	if (!CIFS_CACHE_READ(cinode))
4367 		return cifs_user_readv(iocb, to);
4368 
4369 	if (cap_unix(tcon->ses) &&
4370 	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
4371 	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
4372 		return generic_file_read_iter(iocb, to);
4373 
4374 	/*
4375 	 * We need to hold the sem to be sure nobody modifies lock list
4376 	 * with a brlock that prevents reading.
4377 	 */
4378 	down_read(&cinode->lock_sem);
4379 	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
4380 				     tcon->ses->server->vals->shared_lock_type,
4381 				     0, NULL, CIFS_READ_OP))
4382 		rc = generic_file_read_iter(iocb, to);
4383 	up_read(&cinode->lock_sem);
4384 	return rc;
4385 }
4386 
4387 static ssize_t
cifs_read(struct file * file,char * read_data,size_t read_size,loff_t * offset)4388 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
4389 {
4390 	int rc = -EACCES;
4391 	unsigned int bytes_read = 0;
4392 	unsigned int total_read;
4393 	unsigned int current_read_size;
4394 	unsigned int rsize;
4395 	struct cifs_sb_info *cifs_sb;
4396 	struct cifs_tcon *tcon;
4397 	struct TCP_Server_Info *server;
4398 	unsigned int xid;
4399 	char *cur_offset;
4400 	struct cifsFileInfo *open_file;
4401 	struct cifs_io_parms io_parms = {0};
4402 	int buf_type = CIFS_NO_BUFFER;
4403 	__u32 pid;
4404 
4405 	xid = get_xid();
4406 	cifs_sb = CIFS_FILE_SB(file);
4407 
4408 	/* FIXME: set up handlers for larger reads and/or convert to async */
4409 	rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize);
4410 
4411 	if (file->private_data == NULL) {
4412 		rc = -EBADF;
4413 		free_xid(xid);
4414 		return rc;
4415 	}
4416 	open_file = file->private_data;
4417 	tcon = tlink_tcon(open_file->tlink);
4418 	server = cifs_pick_channel(tcon->ses);
4419 
4420 	if (!server->ops->sync_read) {
4421 		free_xid(xid);
4422 		return -ENOSYS;
4423 	}
4424 
4425 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4426 		pid = open_file->pid;
4427 	else
4428 		pid = current->tgid;
4429 
4430 	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4431 		cifs_dbg(FYI, "attempting read on write only file instance\n");
4432 
4433 	for (total_read = 0, cur_offset = read_data; read_size > total_read;
4434 	     total_read += bytes_read, cur_offset += bytes_read) {
4435 		do {
4436 			current_read_size = min_t(uint, read_size - total_read,
4437 						  rsize);
4438 			/*
4439 			 * For windows me and 9x we do not want to request more
4440 			 * than it negotiated since it will refuse the read
4441 			 * then.
4442 			 */
4443 			if (!(tcon->ses->capabilities &
4444 				tcon->ses->server->vals->cap_large_files)) {
4445 				current_read_size = min_t(uint,
4446 					current_read_size, CIFSMaxBufSize);
4447 			}
4448 			if (open_file->invalidHandle) {
4449 				rc = cifs_reopen_file(open_file, true);
4450 				if (rc != 0)
4451 					break;
4452 			}
4453 			io_parms.pid = pid;
4454 			io_parms.tcon = tcon;
4455 			io_parms.offset = *offset;
4456 			io_parms.length = current_read_size;
4457 			io_parms.server = server;
4458 			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4459 						    &bytes_read, &cur_offset,
4460 						    &buf_type);
4461 		} while (rc == -EAGAIN);
4462 
4463 		if (rc || (bytes_read == 0)) {
4464 			if (total_read) {
4465 				break;
4466 			} else {
4467 				free_xid(xid);
4468 				return rc;
4469 			}
4470 		} else {
4471 			cifs_stats_bytes_read(tcon, total_read);
4472 			*offset += bytes_read;
4473 		}
4474 	}
4475 	free_xid(xid);
4476 	return total_read;
4477 }
4478 
4479 /*
4480  * If the page is mmap'ed into a process' page tables, then we need to make
4481  * sure that it doesn't change while being written back.
4482  */
4483 static vm_fault_t
cifs_page_mkwrite(struct vm_fault * vmf)4484 cifs_page_mkwrite(struct vm_fault *vmf)
4485 {
4486 	struct page *page = vmf->page;
4487 
4488 	/* Wait for the page to be written to the cache before we allow it to
4489 	 * be modified.  We then assume the entire page will need writing back.
4490 	 */
4491 #ifdef CONFIG_CIFS_FSCACHE
4492 	if (PageFsCache(page) &&
4493 	    wait_on_page_fscache_killable(page) < 0)
4494 		return VM_FAULT_RETRY;
4495 #endif
4496 
4497 	wait_on_page_writeback(page);
4498 
4499 	if (lock_page_killable(page) < 0)
4500 		return VM_FAULT_RETRY;
4501 	return VM_FAULT_LOCKED;
4502 }
4503 
4504 static const struct vm_operations_struct cifs_file_vm_ops = {
4505 	.fault = filemap_fault,
4506 	.map_pages = filemap_map_pages,
4507 	.page_mkwrite = cifs_page_mkwrite,
4508 };
4509 
cifs_file_strict_mmap(struct file * file,struct vm_area_struct * vma)4510 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4511 {
4512 	int xid, rc = 0;
4513 	struct inode *inode = file_inode(file);
4514 
4515 	xid = get_xid();
4516 
4517 	if (!CIFS_CACHE_READ(CIFS_I(inode)))
4518 		rc = cifs_zap_mapping(inode);
4519 	if (!rc)
4520 		rc = generic_file_mmap(file, vma);
4521 	if (!rc)
4522 		vma->vm_ops = &cifs_file_vm_ops;
4523 
4524 	free_xid(xid);
4525 	return rc;
4526 }
4527 
cifs_file_mmap(struct file * file,struct vm_area_struct * vma)4528 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4529 {
4530 	int rc, xid;
4531 
4532 	xid = get_xid();
4533 
4534 	rc = cifs_revalidate_file(file);
4535 	if (rc)
4536 		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4537 			 rc);
4538 	if (!rc)
4539 		rc = generic_file_mmap(file, vma);
4540 	if (!rc)
4541 		vma->vm_ops = &cifs_file_vm_ops;
4542 
4543 	free_xid(xid);
4544 	return rc;
4545 }
4546 
4547 static void
cifs_readv_complete(struct work_struct * work)4548 cifs_readv_complete(struct work_struct *work)
4549 {
4550 	unsigned int i, got_bytes;
4551 	struct cifs_readdata *rdata = container_of(work,
4552 						struct cifs_readdata, work);
4553 
4554 	got_bytes = rdata->got_bytes;
4555 	for (i = 0; i < rdata->nr_pages; i++) {
4556 		struct page *page = rdata->pages[i];
4557 
4558 		if (rdata->result == 0 ||
4559 		    (rdata->result == -EAGAIN && got_bytes)) {
4560 			flush_dcache_page(page);
4561 			SetPageUptodate(page);
4562 		} else
4563 			SetPageError(page);
4564 
4565 		if (rdata->result == 0 ||
4566 		    (rdata->result == -EAGAIN && got_bytes))
4567 			cifs_readpage_to_fscache(rdata->mapping->host, page);
4568 
4569 		unlock_page(page);
4570 
4571 		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4572 
4573 		put_page(page);
4574 		rdata->pages[i] = NULL;
4575 	}
4576 	kref_put(&rdata->refcount, cifs_readdata_release);
4577 }
4578 
4579 static int
readpages_fill_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,struct iov_iter * iter,unsigned int len)4580 readpages_fill_pages(struct TCP_Server_Info *server,
4581 		     struct cifs_readdata *rdata, struct iov_iter *iter,
4582 		     unsigned int len)
4583 {
4584 	int result = 0;
4585 	unsigned int i;
4586 	u64 eof;
4587 	pgoff_t eof_index;
4588 	unsigned int nr_pages = rdata->nr_pages;
4589 	unsigned int page_offset = rdata->page_offset;
4590 
4591 	/* determine the eof that the server (probably) has */
4592 	eof = CIFS_I(rdata->mapping->host)->server_eof;
4593 	eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4594 	cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4595 
4596 	rdata->got_bytes = 0;
4597 	rdata->tailsz = PAGE_SIZE;
4598 	for (i = 0; i < nr_pages; i++) {
4599 		struct page *page = rdata->pages[i];
4600 		unsigned int to_read = rdata->pagesz;
4601 		size_t n;
4602 
4603 		if (i == 0)
4604 			to_read -= page_offset;
4605 		else
4606 			page_offset = 0;
4607 
4608 		n = to_read;
4609 
4610 		if (len >= to_read) {
4611 			len -= to_read;
4612 		} else if (len > 0) {
4613 			/* enough for partial page, fill and zero the rest */
4614 			zero_user(page, len + page_offset, to_read - len);
4615 			n = rdata->tailsz = len;
4616 			len = 0;
4617 		} else if (page->index > eof_index) {
4618 			/*
4619 			 * The VFS will not try to do readahead past the
4620 			 * i_size, but it's possible that we have outstanding
4621 			 * writes with gaps in the middle and the i_size hasn't
4622 			 * caught up yet. Populate those with zeroed out pages
4623 			 * to prevent the VFS from repeatedly attempting to
4624 			 * fill them until the writes are flushed.
4625 			 */
4626 			zero_user(page, 0, PAGE_SIZE);
4627 			flush_dcache_page(page);
4628 			SetPageUptodate(page);
4629 			unlock_page(page);
4630 			put_page(page);
4631 			rdata->pages[i] = NULL;
4632 			rdata->nr_pages--;
4633 			continue;
4634 		} else {
4635 			/* no need to hold page hostage */
4636 			unlock_page(page);
4637 			put_page(page);
4638 			rdata->pages[i] = NULL;
4639 			rdata->nr_pages--;
4640 			continue;
4641 		}
4642 
4643 		if (iter)
4644 			result = copy_page_from_iter(
4645 					page, page_offset, n, iter);
4646 #ifdef CONFIG_CIFS_SMB_DIRECT
4647 		else if (rdata->mr)
4648 			result = n;
4649 #endif
4650 		else
4651 			result = cifs_read_page_from_socket(
4652 					server, page, page_offset, n);
4653 		if (result < 0)
4654 			break;
4655 
4656 		rdata->got_bytes += result;
4657 	}
4658 
4659 	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4660 						rdata->got_bytes : result;
4661 }
4662 
4663 static int
cifs_readpages_read_into_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,unsigned int len)4664 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4665 			       struct cifs_readdata *rdata, unsigned int len)
4666 {
4667 	return readpages_fill_pages(server, rdata, NULL, len);
4668 }
4669 
4670 static int
cifs_readpages_copy_into_pages(struct TCP_Server_Info * server,struct cifs_readdata * rdata,struct iov_iter * iter)4671 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4672 			       struct cifs_readdata *rdata,
4673 			       struct iov_iter *iter)
4674 {
4675 	return readpages_fill_pages(server, rdata, iter, iter->count);
4676 }
4677 
cifs_readahead(struct readahead_control * ractl)4678 static void cifs_readahead(struct readahead_control *ractl)
4679 {
4680 	int rc;
4681 	struct cifsFileInfo *open_file = ractl->file->private_data;
4682 	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(ractl->file);
4683 	struct TCP_Server_Info *server;
4684 	pid_t pid;
4685 	unsigned int xid, nr_pages, last_batch_size = 0, cache_nr_pages = 0;
4686 	pgoff_t next_cached = ULONG_MAX;
4687 	bool caching = fscache_cookie_enabled(cifs_inode_cookie(ractl->mapping->host)) &&
4688 		cifs_inode_cookie(ractl->mapping->host)->cache_priv;
4689 	bool check_cache = caching;
4690 
4691 	xid = get_xid();
4692 
4693 	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4694 		pid = open_file->pid;
4695 	else
4696 		pid = current->tgid;
4697 
4698 	rc = 0;
4699 	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4700 
4701 	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4702 		 __func__, ractl->file, ractl->mapping, readahead_count(ractl));
4703 
4704 	/*
4705 	 * Chop the readahead request up into rsize-sized read requests.
4706 	 */
4707 	while ((nr_pages = readahead_count(ractl) - last_batch_size)) {
4708 		unsigned int i, got, rsize;
4709 		struct page *page;
4710 		struct cifs_readdata *rdata;
4711 		struct cifs_credits credits_on_stack;
4712 		struct cifs_credits *credits = &credits_on_stack;
4713 		pgoff_t index = readahead_index(ractl) + last_batch_size;
4714 
4715 		/*
4716 		 * Find out if we have anything cached in the range of
4717 		 * interest, and if so, where the next chunk of cached data is.
4718 		 */
4719 		if (caching) {
4720 			if (check_cache) {
4721 				rc = cifs_fscache_query_occupancy(
4722 					ractl->mapping->host, index, nr_pages,
4723 					&next_cached, &cache_nr_pages);
4724 				if (rc < 0)
4725 					caching = false;
4726 				check_cache = false;
4727 			}
4728 
4729 			if (index == next_cached) {
4730 				/*
4731 				 * TODO: Send a whole batch of pages to be read
4732 				 * by the cache.
4733 				 */
4734 				struct folio *folio = readahead_folio(ractl);
4735 
4736 				last_batch_size = folio_nr_pages(folio);
4737 				if (cifs_readpage_from_fscache(ractl->mapping->host,
4738 							       &folio->page) < 0) {
4739 					/*
4740 					 * TODO: Deal with cache read failure
4741 					 * here, but for the moment, delegate
4742 					 * that to readpage.
4743 					 */
4744 					caching = false;
4745 				}
4746 				folio_unlock(folio);
4747 				next_cached++;
4748 				cache_nr_pages--;
4749 				if (cache_nr_pages == 0)
4750 					check_cache = true;
4751 				continue;
4752 			}
4753 		}
4754 
4755 		if (open_file->invalidHandle) {
4756 			rc = cifs_reopen_file(open_file, true);
4757 			if (rc) {
4758 				if (rc == -EAGAIN)
4759 					continue;
4760 				break;
4761 			}
4762 		}
4763 
4764 		if (cifs_sb->ctx->rsize == 0)
4765 			cifs_sb->ctx->rsize =
4766 				server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4767 							     cifs_sb->ctx);
4768 
4769 		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4770 						   &rsize, credits);
4771 		if (rc)
4772 			break;
4773 		nr_pages = min_t(size_t, rsize / PAGE_SIZE, readahead_count(ractl));
4774 		nr_pages = min_t(size_t, nr_pages, next_cached - index);
4775 
4776 		/*
4777 		 * Give up immediately if rsize is too small to read an entire
4778 		 * page. The VFS will fall back to readpage. We should never
4779 		 * reach this point however since we set ra_pages to 0 when the
4780 		 * rsize is smaller than a cache page.
4781 		 */
4782 		if (unlikely(!nr_pages)) {
4783 			add_credits_and_wake_if(server, credits, 0);
4784 			break;
4785 		}
4786 
4787 		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4788 		if (!rdata) {
4789 			/* best to give up if we're out of mem */
4790 			add_credits_and_wake_if(server, credits, 0);
4791 			break;
4792 		}
4793 
4794 		got = __readahead_batch(ractl, rdata->pages, nr_pages);
4795 		if (got != nr_pages) {
4796 			pr_warn("__readahead_batch() returned %u/%u\n",
4797 				got, nr_pages);
4798 			nr_pages = got;
4799 		}
4800 
4801 		rdata->nr_pages = nr_pages;
4802 		rdata->bytes	= readahead_batch_length(ractl);
4803 		rdata->cfile	= cifsFileInfo_get(open_file);
4804 		rdata->server	= server;
4805 		rdata->mapping	= ractl->mapping;
4806 		rdata->offset	= readahead_pos(ractl);
4807 		rdata->pid	= pid;
4808 		rdata->pagesz	= PAGE_SIZE;
4809 		rdata->tailsz	= PAGE_SIZE;
4810 		rdata->read_into_pages = cifs_readpages_read_into_pages;
4811 		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4812 		rdata->credits	= credits_on_stack;
4813 
4814 		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4815 		if (!rc) {
4816 			if (rdata->cfile->invalidHandle)
4817 				rc = -EAGAIN;
4818 			else
4819 				rc = server->ops->async_readv(rdata);
4820 		}
4821 
4822 		if (rc) {
4823 			add_credits_and_wake_if(server, &rdata->credits, 0);
4824 			for (i = 0; i < rdata->nr_pages; i++) {
4825 				page = rdata->pages[i];
4826 				unlock_page(page);
4827 				put_page(page);
4828 			}
4829 			/* Fallback to the readpage in error/reconnect cases */
4830 			kref_put(&rdata->refcount, cifs_readdata_release);
4831 			break;
4832 		}
4833 
4834 		kref_put(&rdata->refcount, cifs_readdata_release);
4835 		last_batch_size = nr_pages;
4836 	}
4837 
4838 	free_xid(xid);
4839 }
4840 
4841 /*
4842  * cifs_readpage_worker must be called with the page pinned
4843  */
cifs_readpage_worker(struct file * file,struct page * page,loff_t * poffset)4844 static int cifs_readpage_worker(struct file *file, struct page *page,
4845 	loff_t *poffset)
4846 {
4847 	char *read_data;
4848 	int rc;
4849 
4850 	/* Is the page cached? */
4851 	rc = cifs_readpage_from_fscache(file_inode(file), page);
4852 	if (rc == 0)
4853 		goto read_complete;
4854 
4855 	read_data = kmap(page);
4856 	/* for reads over a certain size could initiate async read ahead */
4857 
4858 	rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4859 
4860 	if (rc < 0)
4861 		goto io_error;
4862 	else
4863 		cifs_dbg(FYI, "Bytes read %d\n", rc);
4864 
4865 	/* we do not want atime to be less than mtime, it broke some apps */
4866 	file_inode(file)->i_atime = current_time(file_inode(file));
4867 	if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4868 		file_inode(file)->i_atime = file_inode(file)->i_mtime;
4869 	else
4870 		file_inode(file)->i_atime = current_time(file_inode(file));
4871 
4872 	if (PAGE_SIZE > rc)
4873 		memset(read_data + rc, 0, PAGE_SIZE - rc);
4874 
4875 	flush_dcache_page(page);
4876 	SetPageUptodate(page);
4877 
4878 	/* send this page to the cache */
4879 	cifs_readpage_to_fscache(file_inode(file), page);
4880 
4881 	rc = 0;
4882 
4883 io_error:
4884 	kunmap(page);
4885 	unlock_page(page);
4886 
4887 read_complete:
4888 	return rc;
4889 }
4890 
cifs_read_folio(struct file * file,struct folio * folio)4891 static int cifs_read_folio(struct file *file, struct folio *folio)
4892 {
4893 	struct page *page = &folio->page;
4894 	loff_t offset = page_file_offset(page);
4895 	int rc = -EACCES;
4896 	unsigned int xid;
4897 
4898 	xid = get_xid();
4899 
4900 	if (file->private_data == NULL) {
4901 		rc = -EBADF;
4902 		free_xid(xid);
4903 		return rc;
4904 	}
4905 
4906 	cifs_dbg(FYI, "read_folio %p at offset %d 0x%x\n",
4907 		 page, (int)offset, (int)offset);
4908 
4909 	rc = cifs_readpage_worker(file, page, &offset);
4910 
4911 	free_xid(xid);
4912 	return rc;
4913 }
4914 
is_inode_writable(struct cifsInodeInfo * cifs_inode)4915 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4916 {
4917 	struct cifsFileInfo *open_file;
4918 
4919 	spin_lock(&cifs_inode->open_file_lock);
4920 	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4921 		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4922 			spin_unlock(&cifs_inode->open_file_lock);
4923 			return 1;
4924 		}
4925 	}
4926 	spin_unlock(&cifs_inode->open_file_lock);
4927 	return 0;
4928 }
4929 
4930 /* We do not want to update the file size from server for inodes
4931    open for write - to avoid races with writepage extending
4932    the file - in the future we could consider allowing
4933    refreshing the inode only on increases in the file size
4934    but this is tricky to do without racing with writebehind
4935    page caching in the current Linux kernel design */
is_size_safe_to_change(struct cifsInodeInfo * cifsInode,__u64 end_of_file)4936 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4937 {
4938 	if (!cifsInode)
4939 		return true;
4940 
4941 	if (is_inode_writable(cifsInode)) {
4942 		/* This inode is open for write at least once */
4943 		struct cifs_sb_info *cifs_sb;
4944 
4945 		cifs_sb = CIFS_SB(cifsInode->netfs.inode.i_sb);
4946 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4947 			/* since no page cache to corrupt on directio
4948 			we can change size safely */
4949 			return true;
4950 		}
4951 
4952 		if (i_size_read(&cifsInode->netfs.inode) < end_of_file)
4953 			return true;
4954 
4955 		return false;
4956 	} else
4957 		return true;
4958 }
4959 
cifs_write_begin(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,struct page ** pagep,void ** fsdata)4960 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4961 			loff_t pos, unsigned len,
4962 			struct page **pagep, void **fsdata)
4963 {
4964 	int oncethru = 0;
4965 	pgoff_t index = pos >> PAGE_SHIFT;
4966 	loff_t offset = pos & (PAGE_SIZE - 1);
4967 	loff_t page_start = pos & PAGE_MASK;
4968 	loff_t i_size;
4969 	struct page *page;
4970 	int rc = 0;
4971 
4972 	cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4973 
4974 start:
4975 	page = grab_cache_page_write_begin(mapping, index);
4976 	if (!page) {
4977 		rc = -ENOMEM;
4978 		goto out;
4979 	}
4980 
4981 	if (PageUptodate(page))
4982 		goto out;
4983 
4984 	/*
4985 	 * If we write a full page it will be up to date, no need to read from
4986 	 * the server. If the write is short, we'll end up doing a sync write
4987 	 * instead.
4988 	 */
4989 	if (len == PAGE_SIZE)
4990 		goto out;
4991 
4992 	/*
4993 	 * optimize away the read when we have an oplock, and we're not
4994 	 * expecting to use any of the data we'd be reading in. That
4995 	 * is, when the page lies beyond the EOF, or straddles the EOF
4996 	 * and the write will cover all of the existing data.
4997 	 */
4998 	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4999 		i_size = i_size_read(mapping->host);
5000 		if (page_start >= i_size ||
5001 		    (offset == 0 && (pos + len) >= i_size)) {
5002 			zero_user_segments(page, 0, offset,
5003 					   offset + len,
5004 					   PAGE_SIZE);
5005 			/*
5006 			 * PageChecked means that the parts of the page
5007 			 * to which we're not writing are considered up
5008 			 * to date. Once the data is copied to the
5009 			 * page, it can be set uptodate.
5010 			 */
5011 			SetPageChecked(page);
5012 			goto out;
5013 		}
5014 	}
5015 
5016 	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
5017 		/*
5018 		 * might as well read a page, it is fast enough. If we get
5019 		 * an error, we don't need to return it. cifs_write_end will
5020 		 * do a sync write instead since PG_uptodate isn't set.
5021 		 */
5022 		cifs_readpage_worker(file, page, &page_start);
5023 		put_page(page);
5024 		oncethru = 1;
5025 		goto start;
5026 	} else {
5027 		/* we could try using another file handle if there is one -
5028 		   but how would we lock it to prevent close of that handle
5029 		   racing with this read? In any case
5030 		   this will be written out by write_end so is fine */
5031 	}
5032 out:
5033 	*pagep = page;
5034 	return rc;
5035 }
5036 
cifs_release_folio(struct folio * folio,gfp_t gfp)5037 static bool cifs_release_folio(struct folio *folio, gfp_t gfp)
5038 {
5039 	if (folio_test_private(folio))
5040 		return 0;
5041 	if (folio_test_fscache(folio)) {
5042 		if (current_is_kswapd() || !(gfp & __GFP_FS))
5043 			return false;
5044 		folio_wait_fscache(folio);
5045 	}
5046 	fscache_note_page_release(cifs_inode_cookie(folio->mapping->host));
5047 	return true;
5048 }
5049 
cifs_invalidate_folio(struct folio * folio,size_t offset,size_t length)5050 static void cifs_invalidate_folio(struct folio *folio, size_t offset,
5051 				 size_t length)
5052 {
5053 	folio_wait_fscache(folio);
5054 }
5055 
cifs_launder_folio(struct folio * folio)5056 static int cifs_launder_folio(struct folio *folio)
5057 {
5058 	int rc = 0;
5059 	loff_t range_start = folio_pos(folio);
5060 	loff_t range_end = range_start + folio_size(folio);
5061 	struct writeback_control wbc = {
5062 		.sync_mode = WB_SYNC_ALL,
5063 		.nr_to_write = 0,
5064 		.range_start = range_start,
5065 		.range_end = range_end,
5066 	};
5067 
5068 	cifs_dbg(FYI, "Launder page: %lu\n", folio->index);
5069 
5070 	if (folio_clear_dirty_for_io(folio))
5071 		rc = cifs_writepage_locked(&folio->page, &wbc);
5072 
5073 	folio_wait_fscache(folio);
5074 	return rc;
5075 }
5076 
cifs_oplock_break(struct work_struct * work)5077 void cifs_oplock_break(struct work_struct *work)
5078 {
5079 	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
5080 						  oplock_break);
5081 	struct inode *inode = d_inode(cfile->dentry);
5082 	struct cifsInodeInfo *cinode = CIFS_I(inode);
5083 	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
5084 	struct TCP_Server_Info *server = tcon->ses->server;
5085 	int rc = 0;
5086 	bool purge_cache = false;
5087 
5088 	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
5089 			TASK_UNINTERRUPTIBLE);
5090 
5091 	server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
5092 				      cfile->oplock_epoch, &purge_cache);
5093 
5094 	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
5095 						cifs_has_mand_locks(cinode)) {
5096 		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
5097 			 inode);
5098 		cinode->oplock = 0;
5099 	}
5100 
5101 	if (inode && S_ISREG(inode->i_mode)) {
5102 		if (CIFS_CACHE_READ(cinode))
5103 			break_lease(inode, O_RDONLY);
5104 		else
5105 			break_lease(inode, O_WRONLY);
5106 		rc = filemap_fdatawrite(inode->i_mapping);
5107 		if (!CIFS_CACHE_READ(cinode) || purge_cache) {
5108 			rc = filemap_fdatawait(inode->i_mapping);
5109 			mapping_set_error(inode->i_mapping, rc);
5110 			cifs_zap_mapping(inode);
5111 		}
5112 		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
5113 		if (CIFS_CACHE_WRITE(cinode))
5114 			goto oplock_break_ack;
5115 	}
5116 
5117 	rc = cifs_push_locks(cfile);
5118 	if (rc)
5119 		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
5120 
5121 oplock_break_ack:
5122 	/*
5123 	 * releasing stale oplock after recent reconnect of smb session using
5124 	 * a now incorrect file handle is not a data integrity issue but do
5125 	 * not bother sending an oplock release if session to server still is
5126 	 * disconnected since oplock already released by the server
5127 	 */
5128 	if (!cfile->oplock_break_cancelled) {
5129 		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
5130 							     cinode);
5131 		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
5132 	}
5133 
5134 	_cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
5135 	cifs_done_oplock_break(cinode);
5136 }
5137 
5138 /*
5139  * The presence of cifs_direct_io() in the address space ops vector
5140  * allowes open() O_DIRECT flags which would have failed otherwise.
5141  *
5142  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
5143  * so this method should never be called.
5144  *
5145  * Direct IO is not yet supported in the cached mode.
5146  */
5147 static ssize_t
cifs_direct_io(struct kiocb * iocb,struct iov_iter * iter)5148 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
5149 {
5150         /*
5151          * FIXME
5152          * Eventually need to support direct IO for non forcedirectio mounts
5153          */
5154         return -EINVAL;
5155 }
5156 
cifs_swap_activate(struct swap_info_struct * sis,struct file * swap_file,sector_t * span)5157 static int cifs_swap_activate(struct swap_info_struct *sis,
5158 			      struct file *swap_file, sector_t *span)
5159 {
5160 	struct cifsFileInfo *cfile = swap_file->private_data;
5161 	struct inode *inode = swap_file->f_mapping->host;
5162 	unsigned long blocks;
5163 	long long isize;
5164 
5165 	cifs_dbg(FYI, "swap activate\n");
5166 
5167 	if (!swap_file->f_mapping->a_ops->swap_rw)
5168 		/* Cannot support swap */
5169 		return -EINVAL;
5170 
5171 	spin_lock(&inode->i_lock);
5172 	blocks = inode->i_blocks;
5173 	isize = inode->i_size;
5174 	spin_unlock(&inode->i_lock);
5175 	if (blocks*512 < isize) {
5176 		pr_warn("swap activate: swapfile has holes\n");
5177 		return -EINVAL;
5178 	}
5179 	*span = sis->pages;
5180 
5181 	pr_warn_once("Swap support over SMB3 is experimental\n");
5182 
5183 	/*
5184 	 * TODO: consider adding ACL (or documenting how) to prevent other
5185 	 * users (on this or other systems) from reading it
5186 	 */
5187 
5188 
5189 	/* TODO: add sk_set_memalloc(inet) or similar */
5190 
5191 	if (cfile)
5192 		cfile->swapfile = true;
5193 	/*
5194 	 * TODO: Since file already open, we can't open with DENY_ALL here
5195 	 * but we could add call to grab a byte range lock to prevent others
5196 	 * from reading or writing the file
5197 	 */
5198 
5199 	sis->flags |= SWP_FS_OPS;
5200 	return add_swap_extent(sis, 0, sis->max, 0);
5201 }
5202 
cifs_swap_deactivate(struct file * file)5203 static void cifs_swap_deactivate(struct file *file)
5204 {
5205 	struct cifsFileInfo *cfile = file->private_data;
5206 
5207 	cifs_dbg(FYI, "swap deactivate\n");
5208 
5209 	/* TODO: undo sk_set_memalloc(inet) will eventually be needed */
5210 
5211 	if (cfile)
5212 		cfile->swapfile = false;
5213 
5214 	/* do we need to unpin (or unlock) the file */
5215 }
5216 
5217 /*
5218  * Mark a page as having been made dirty and thus needing writeback.  We also
5219  * need to pin the cache object to write back to.
5220  */
5221 #ifdef CONFIG_CIFS_FSCACHE
cifs_dirty_folio(struct address_space * mapping,struct folio * folio)5222 static bool cifs_dirty_folio(struct address_space *mapping, struct folio *folio)
5223 {
5224 	return fscache_dirty_folio(mapping, folio,
5225 					cifs_inode_cookie(mapping->host));
5226 }
5227 #else
5228 #define cifs_dirty_folio filemap_dirty_folio
5229 #endif
5230 
5231 const struct address_space_operations cifs_addr_ops = {
5232 	.read_folio = cifs_read_folio,
5233 	.readahead = cifs_readahead,
5234 	.writepage = cifs_writepage,
5235 	.writepages = cifs_writepages,
5236 	.write_begin = cifs_write_begin,
5237 	.write_end = cifs_write_end,
5238 	.dirty_folio = cifs_dirty_folio,
5239 	.release_folio = cifs_release_folio,
5240 	.direct_IO = cifs_direct_io,
5241 	.invalidate_folio = cifs_invalidate_folio,
5242 	.launder_folio = cifs_launder_folio,
5243 	/*
5244 	 * TODO: investigate and if useful we could add an cifs_migratePage
5245 	 * helper (under an CONFIG_MIGRATION) in the future, and also
5246 	 * investigate and add an is_dirty_writeback helper if needed
5247 	 */
5248 	.swap_activate = cifs_swap_activate,
5249 	.swap_deactivate = cifs_swap_deactivate,
5250 };
5251 
5252 /*
5253  * cifs_readahead requires the server to support a buffer large enough to
5254  * contain the header plus one complete page of data.  Otherwise, we need
5255  * to leave cifs_readahead out of the address space operations.
5256  */
5257 const struct address_space_operations cifs_addr_ops_smallbuf = {
5258 	.read_folio = cifs_read_folio,
5259 	.writepage = cifs_writepage,
5260 	.writepages = cifs_writepages,
5261 	.write_begin = cifs_write_begin,
5262 	.write_end = cifs_write_end,
5263 	.dirty_folio = cifs_dirty_folio,
5264 	.release_folio = cifs_release_folio,
5265 	.invalidate_folio = cifs_invalidate_folio,
5266 	.launder_folio = cifs_launder_folio,
5267 };
5268