]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/cifs/file.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cifs: add FL_CLOSE to fl_flags mask in cifs_read_flock
[mirror_ubuntu-jammy-kernel.git] / fs / cifs / file.c
1 /*
2 * fs/cifs/file.c
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 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <linux/swap.h>
36 #include <asm/div64.h>
37 #include "cifsfs.h"
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "fscache.h"
45
46 static inline int cifs_convert_flags(unsigned int flags)
47 {
48 if ((flags & O_ACCMODE) == O_RDONLY)
49 return GENERIC_READ;
50 else if ((flags & O_ACCMODE) == O_WRONLY)
51 return GENERIC_WRITE;
52 else if ((flags & O_ACCMODE) == O_RDWR) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ | GENERIC_WRITE);
57 }
58
59 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61 FILE_READ_DATA);
62 }
63
64 static u32 cifs_posix_convert_flags(unsigned int flags)
65 {
66 u32 posix_flags = 0;
67
68 if ((flags & O_ACCMODE) == O_RDONLY)
69 posix_flags = SMB_O_RDONLY;
70 else if ((flags & O_ACCMODE) == O_WRONLY)
71 posix_flags = SMB_O_WRONLY;
72 else if ((flags & O_ACCMODE) == O_RDWR)
73 posix_flags = SMB_O_RDWR;
74
75 if (flags & O_CREAT)
76 posix_flags |= SMB_O_CREAT;
77 if (flags & O_EXCL)
78 posix_flags |= SMB_O_EXCL;
79 if (flags & O_TRUNC)
80 posix_flags |= SMB_O_TRUNC;
81 /* be safe and imply O_SYNC for O_DSYNC */
82 if (flags & O_DSYNC)
83 posix_flags |= SMB_O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= SMB_O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= SMB_O_NOFOLLOW;
88 if (flags & O_DIRECT)
89 posix_flags |= SMB_O_DIRECT;
90
91 return posix_flags;
92 }
93
94 static inline int cifs_get_disposition(unsigned int flags)
95 {
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 return FILE_CREATE;
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
101 return FILE_OPEN_IF;
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
104 else
105 return FILE_OPEN;
106 }
107
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109 struct super_block *sb, int mode, unsigned int f_flags,
110 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
111 {
112 int rc;
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
115 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116 struct cifs_fattr fattr;
117 struct tcon_link *tlink;
118 struct cifs_tcon *tcon;
119
120 cFYI(1, "posix open %s", full_path);
121
122 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123 if (presp_data == NULL)
124 return -ENOMEM;
125
126 tlink = cifs_sb_tlink(cifs_sb);
127 if (IS_ERR(tlink)) {
128 rc = PTR_ERR(tlink);
129 goto posix_open_ret;
130 }
131
132 tcon = tlink_tcon(tlink);
133 mode &= ~current_umask();
134
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137 poplock, full_path, cifs_sb->local_nls,
138 cifs_sb->mnt_cifs_flags &
139 CIFS_MOUNT_MAP_SPECIAL_CHR);
140 cifs_put_tlink(tlink);
141
142 if (rc)
143 goto posix_open_ret;
144
145 if (presp_data->Type == cpu_to_le32(-1))
146 goto posix_open_ret; /* open ok, caller does qpathinfo */
147
148 if (!pinode)
149 goto posix_open_ret; /* caller does not need info */
150
151 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
152
153 /* get new inode and set it up */
154 if (*pinode == NULL) {
155 cifs_fill_uniqueid(sb, &fattr);
156 *pinode = cifs_iget(sb, &fattr);
157 if (!*pinode) {
158 rc = -ENOMEM;
159 goto posix_open_ret;
160 }
161 } else {
162 cifs_fattr_to_inode(*pinode, &fattr);
163 }
164
165 posix_open_ret:
166 kfree(presp_data);
167 return rc;
168 }
169
170 static int
171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
172 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
173 struct cifs_fid *fid, unsigned int xid)
174 {
175 int rc;
176 int desired_access;
177 int disposition;
178 int create_options = CREATE_NOT_DIR;
179 FILE_ALL_INFO *buf;
180 struct TCP_Server_Info *server = tcon->ses->server;
181
182 if (!server->ops->open)
183 return -ENOSYS;
184
185 desired_access = cifs_convert_flags(f_flags);
186
187 /*********************************************************************
188 * open flag mapping table:
189 *
190 * POSIX Flag CIFS Disposition
191 * ---------- ----------------
192 * O_CREAT FILE_OPEN_IF
193 * O_CREAT | O_EXCL FILE_CREATE
194 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
195 * O_TRUNC FILE_OVERWRITE
196 * none of the above FILE_OPEN
197 *
198 * Note that there is not a direct match between disposition
199 * FILE_SUPERSEDE (ie create whether or not file exists although
200 * O_CREAT | O_TRUNC is similar but truncates the existing
201 * file rather than creating a new file as FILE_SUPERSEDE does
202 * (which uses the attributes / metadata passed in on open call)
203 *?
204 *? O_SYNC is a reasonable match to CIFS writethrough flag
205 *? and the read write flags match reasonably. O_LARGEFILE
206 *? is irrelevant because largefile support is always used
207 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
208 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
209 *********************************************************************/
210
211 disposition = cifs_get_disposition(f_flags);
212
213 /* BB pass O_SYNC flag through on file attributes .. BB */
214
215 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
216 if (!buf)
217 return -ENOMEM;
218
219 if (backup_cred(cifs_sb))
220 create_options |= CREATE_OPEN_BACKUP_INTENT;
221
222 rc = server->ops->open(xid, tcon, full_path, disposition,
223 desired_access, create_options, fid, oplock, buf,
224 cifs_sb);
225
226 if (rc)
227 goto out;
228
229 if (tcon->unix_ext)
230 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
231 xid);
232 else
233 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
234 xid, &fid->netfid);
235
236 out:
237 kfree(buf);
238 return rc;
239 }
240
241 struct cifsFileInfo *
242 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
243 struct tcon_link *tlink, __u32 oplock)
244 {
245 struct dentry *dentry = file->f_path.dentry;
246 struct inode *inode = dentry->d_inode;
247 struct cifsInodeInfo *cinode = CIFS_I(inode);
248 struct cifsFileInfo *cfile;
249 struct cifs_fid_locks *fdlocks;
250 struct cifs_tcon *tcon = tlink_tcon(tlink);
251
252 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
253 if (cfile == NULL)
254 return cfile;
255
256 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
257 if (!fdlocks) {
258 kfree(cfile);
259 return NULL;
260 }
261
262 INIT_LIST_HEAD(&fdlocks->locks);
263 fdlocks->cfile = cfile;
264 cfile->llist = fdlocks;
265 down_write(&cinode->lock_sem);
266 list_add(&fdlocks->llist, &cinode->llist);
267 up_write(&cinode->lock_sem);
268
269 cfile->count = 1;
270 cfile->pid = current->tgid;
271 cfile->uid = current_fsuid();
272 cfile->dentry = dget(dentry);
273 cfile->f_flags = file->f_flags;
274 cfile->invalidHandle = false;
275 cfile->tlink = cifs_get_tlink(tlink);
276 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
277 mutex_init(&cfile->fh_mutex);
278
279 spin_lock(&cifs_file_list_lock);
280 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE)
281 oplock = fid->pending_open->oplock;
282 list_del(&fid->pending_open->olist);
283
284 tlink_tcon(tlink)->ses->server->ops->set_fid(cfile, fid, oplock);
285
286 list_add(&cfile->tlist, &tcon->openFileList);
287 /* if readable file instance put first in list*/
288 if (file->f_mode & FMODE_READ)
289 list_add(&cfile->flist, &cinode->openFileList);
290 else
291 list_add_tail(&cfile->flist, &cinode->openFileList);
292 spin_unlock(&cifs_file_list_lock);
293
294 file->private_data = cfile;
295 return cfile;
296 }
297
298 struct cifsFileInfo *
299 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
300 {
301 spin_lock(&cifs_file_list_lock);
302 cifsFileInfo_get_locked(cifs_file);
303 spin_unlock(&cifs_file_list_lock);
304 return cifs_file;
305 }
306
307 /*
308 * Release a reference on the file private data. This may involve closing
309 * the filehandle out on the server. Must be called without holding
310 * cifs_file_list_lock.
311 */
312 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
313 {
314 struct inode *inode = cifs_file->dentry->d_inode;
315 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
316 struct TCP_Server_Info *server = tcon->ses->server;
317 struct cifsInodeInfo *cifsi = CIFS_I(inode);
318 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
319 struct cifsLockInfo *li, *tmp;
320 struct cifs_fid fid;
321 struct cifs_pending_open open;
322
323 spin_lock(&cifs_file_list_lock);
324 if (--cifs_file->count > 0) {
325 spin_unlock(&cifs_file_list_lock);
326 return;
327 }
328
329 if (server->ops->get_lease_key)
330 server->ops->get_lease_key(inode, &fid);
331
332 /* store open in pending opens to make sure we don't miss lease break */
333 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
334
335 /* remove it from the lists */
336 list_del(&cifs_file->flist);
337 list_del(&cifs_file->tlist);
338
339 if (list_empty(&cifsi->openFileList)) {
340 cFYI(1, "closing last open instance for inode %p",
341 cifs_file->dentry->d_inode);
342 /*
343 * In strict cache mode we need invalidate mapping on the last
344 * close because it may cause a error when we open this file
345 * again and get at least level II oplock.
346 */
347 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
348 CIFS_I(inode)->invalid_mapping = true;
349 cifs_set_oplock_level(cifsi, 0);
350 }
351 spin_unlock(&cifs_file_list_lock);
352
353 cancel_work_sync(&cifs_file->oplock_break);
354
355 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
356 struct TCP_Server_Info *server = tcon->ses->server;
357 unsigned int xid;
358 int rc = -ENOSYS;
359
360 xid = get_xid();
361 if (server->ops->close)
362 rc = server->ops->close(xid, tcon, &cifs_file->fid);
363 free_xid(xid);
364 }
365
366 cifs_del_pending_open(&open);
367
368 /*
369 * Delete any outstanding lock records. We'll lose them when the file
370 * is closed anyway.
371 */
372 down_write(&cifsi->lock_sem);
373 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
374 list_del(&li->llist);
375 cifs_del_lock_waiters(li);
376 kfree(li);
377 }
378 list_del(&cifs_file->llist->llist);
379 kfree(cifs_file->llist);
380 up_write(&cifsi->lock_sem);
381
382 cifs_put_tlink(cifs_file->tlink);
383 dput(cifs_file->dentry);
384 kfree(cifs_file);
385 }
386
387 int cifs_open(struct inode *inode, struct file *file)
388
389 {
390 int rc = -EACCES;
391 unsigned int xid;
392 __u32 oplock;
393 struct cifs_sb_info *cifs_sb;
394 struct TCP_Server_Info *server;
395 struct cifs_tcon *tcon;
396 struct tcon_link *tlink;
397 struct cifsFileInfo *cfile = NULL;
398 char *full_path = NULL;
399 bool posix_open_ok = false;
400 struct cifs_fid fid;
401 struct cifs_pending_open open;
402
403 xid = get_xid();
404
405 cifs_sb = CIFS_SB(inode->i_sb);
406 tlink = cifs_sb_tlink(cifs_sb);
407 if (IS_ERR(tlink)) {
408 free_xid(xid);
409 return PTR_ERR(tlink);
410 }
411 tcon = tlink_tcon(tlink);
412 server = tcon->ses->server;
413
414 full_path = build_path_from_dentry(file->f_path.dentry);
415 if (full_path == NULL) {
416 rc = -ENOMEM;
417 goto out;
418 }
419
420 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
421 inode, file->f_flags, full_path);
422
423 if (server->oplocks)
424 oplock = REQ_OPLOCK;
425 else
426 oplock = 0;
427
428 if (!tcon->broken_posix_open && tcon->unix_ext &&
429 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
430 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
431 /* can not refresh inode info since size could be stale */
432 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
433 cifs_sb->mnt_file_mode /* ignored */,
434 file->f_flags, &oplock, &fid.netfid, xid);
435 if (rc == 0) {
436 cFYI(1, "posix open succeeded");
437 posix_open_ok = true;
438 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
439 if (tcon->ses->serverNOS)
440 cERROR(1, "server %s of type %s returned"
441 " unexpected error on SMB posix open"
442 ", disabling posix open support."
443 " Check if server update available.",
444 tcon->ses->serverName,
445 tcon->ses->serverNOS);
446 tcon->broken_posix_open = true;
447 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
448 (rc != -EOPNOTSUPP)) /* path not found or net err */
449 goto out;
450 /*
451 * Else fallthrough to retry open the old way on network i/o
452 * or DFS errors.
453 */
454 }
455
456 if (server->ops->get_lease_key)
457 server->ops->get_lease_key(inode, &fid);
458
459 cifs_add_pending_open(&fid, tlink, &open);
460
461 if (!posix_open_ok) {
462 if (server->ops->get_lease_key)
463 server->ops->get_lease_key(inode, &fid);
464
465 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
466 file->f_flags, &oplock, &fid, xid);
467 if (rc) {
468 cifs_del_pending_open(&open);
469 goto out;
470 }
471 }
472
473 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
474 if (cfile == NULL) {
475 if (server->ops->close)
476 server->ops->close(xid, tcon, &fid);
477 cifs_del_pending_open(&open);
478 rc = -ENOMEM;
479 goto out;
480 }
481
482 cifs_fscache_set_inode_cookie(inode, file);
483
484 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
485 /*
486 * Time to set mode which we can not set earlier due to
487 * problems creating new read-only files.
488 */
489 struct cifs_unix_set_info_args args = {
490 .mode = inode->i_mode,
491 .uid = NO_CHANGE_64,
492 .gid = NO_CHANGE_64,
493 .ctime = NO_CHANGE_64,
494 .atime = NO_CHANGE_64,
495 .mtime = NO_CHANGE_64,
496 .device = 0,
497 };
498 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
499 cfile->pid);
500 }
501
502 out:
503 kfree(full_path);
504 free_xid(xid);
505 cifs_put_tlink(tlink);
506 return rc;
507 }
508
509 /*
510 * Try to reacquire byte range locks that were released when session
511 * to server was lost
512 */
513 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
514 {
515 int rc = 0;
516
517 /* BB list all locks open on this file and relock */
518
519 return rc;
520 }
521
522 static int
523 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
524 {
525 int rc = -EACCES;
526 unsigned int xid;
527 __u32 oplock;
528 struct cifs_sb_info *cifs_sb;
529 struct cifs_tcon *tcon;
530 struct TCP_Server_Info *server;
531 struct cifsInodeInfo *cinode;
532 struct inode *inode;
533 char *full_path = NULL;
534 int desired_access;
535 int disposition = FILE_OPEN;
536 int create_options = CREATE_NOT_DIR;
537 struct cifs_fid fid;
538
539 xid = get_xid();
540 mutex_lock(&cfile->fh_mutex);
541 if (!cfile->invalidHandle) {
542 mutex_unlock(&cfile->fh_mutex);
543 rc = 0;
544 free_xid(xid);
545 return rc;
546 }
547
548 inode = cfile->dentry->d_inode;
549 cifs_sb = CIFS_SB(inode->i_sb);
550 tcon = tlink_tcon(cfile->tlink);
551 server = tcon->ses->server;
552
553 /*
554 * Can not grab rename sem here because various ops, including those
555 * that already have the rename sem can end up causing writepage to get
556 * called and if the server was down that means we end up here, and we
557 * can never tell if the caller already has the rename_sem.
558 */
559 full_path = build_path_from_dentry(cfile->dentry);
560 if (full_path == NULL) {
561 rc = -ENOMEM;
562 mutex_unlock(&cfile->fh_mutex);
563 free_xid(xid);
564 return rc;
565 }
566
567 cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode, cfile->f_flags,
568 full_path);
569
570 if (tcon->ses->server->oplocks)
571 oplock = REQ_OPLOCK;
572 else
573 oplock = 0;
574
575 if (tcon->unix_ext && cap_unix(tcon->ses) &&
576 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
577 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
578 /*
579 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
580 * original open. Must mask them off for a reopen.
581 */
582 unsigned int oflags = cfile->f_flags &
583 ~(O_CREAT | O_EXCL | O_TRUNC);
584
585 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
586 cifs_sb->mnt_file_mode /* ignored */,
587 oflags, &oplock, &fid.netfid, xid);
588 if (rc == 0) {
589 cFYI(1, "posix reopen succeeded");
590 goto reopen_success;
591 }
592 /*
593 * fallthrough to retry open the old way on errors, especially
594 * in the reconnect path it is important to retry hard
595 */
596 }
597
598 desired_access = cifs_convert_flags(cfile->f_flags);
599
600 if (backup_cred(cifs_sb))
601 create_options |= CREATE_OPEN_BACKUP_INTENT;
602
603 if (server->ops->get_lease_key)
604 server->ops->get_lease_key(inode, &fid);
605
606 /*
607 * Can not refresh inode by passing in file_info buf to be returned by
608 * CIFSSMBOpen and then calling get_inode_info with returned buf since
609 * file might have write behind data that needs to be flushed and server
610 * version of file size can be stale. If we knew for sure that inode was
611 * not dirty locally we could do this.
612 */
613 rc = server->ops->open(xid, tcon, full_path, disposition,
614 desired_access, create_options, &fid, &oplock,
615 NULL, cifs_sb);
616 if (rc) {
617 mutex_unlock(&cfile->fh_mutex);
618 cFYI(1, "cifs_reopen returned 0x%x", rc);
619 cFYI(1, "oplock: %d", oplock);
620 goto reopen_error_exit;
621 }
622
623 reopen_success:
624 cfile->invalidHandle = false;
625 mutex_unlock(&cfile->fh_mutex);
626 cinode = CIFS_I(inode);
627
628 if (can_flush) {
629 rc = filemap_write_and_wait(inode->i_mapping);
630 mapping_set_error(inode->i_mapping, rc);
631
632 if (tcon->unix_ext)
633 rc = cifs_get_inode_info_unix(&inode, full_path,
634 inode->i_sb, xid);
635 else
636 rc = cifs_get_inode_info(&inode, full_path, NULL,
637 inode->i_sb, xid, NULL);
638 }
639 /*
640 * Else we are writing out data to server already and could deadlock if
641 * we tried to flush data, and since we do not know if we have data that
642 * would invalidate the current end of file on the server we can not go
643 * to the server to get the new inode info.
644 */
645
646 server->ops->set_fid(cfile, &fid, oplock);
647 cifs_relock_file(cfile);
648
649 reopen_error_exit:
650 kfree(full_path);
651 free_xid(xid);
652 return rc;
653 }
654
655 int cifs_close(struct inode *inode, struct file *file)
656 {
657 if (file->private_data != NULL) {
658 cifsFileInfo_put(file->private_data);
659 file->private_data = NULL;
660 }
661
662 /* return code from the ->release op is always ignored */
663 return 0;
664 }
665
666 int cifs_closedir(struct inode *inode, struct file *file)
667 {
668 int rc = 0;
669 unsigned int xid;
670 struct cifsFileInfo *cfile = file->private_data;
671 struct cifs_tcon *tcon;
672 struct TCP_Server_Info *server;
673 char *buf;
674
675 cFYI(1, "Closedir inode = 0x%p", inode);
676
677 if (cfile == NULL)
678 return rc;
679
680 xid = get_xid();
681 tcon = tlink_tcon(cfile->tlink);
682 server = tcon->ses->server;
683
684 cFYI(1, "Freeing private data in close dir");
685 spin_lock(&cifs_file_list_lock);
686 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
687 cfile->invalidHandle = true;
688 spin_unlock(&cifs_file_list_lock);
689 if (server->ops->close_dir)
690 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
691 else
692 rc = -ENOSYS;
693 cFYI(1, "Closing uncompleted readdir with rc %d", rc);
694 /* not much we can do if it fails anyway, ignore rc */
695 rc = 0;
696 } else
697 spin_unlock(&cifs_file_list_lock);
698
699 buf = cfile->srch_inf.ntwrk_buf_start;
700 if (buf) {
701 cFYI(1, "closedir free smb buf in srch struct");
702 cfile->srch_inf.ntwrk_buf_start = NULL;
703 if (cfile->srch_inf.smallBuf)
704 cifs_small_buf_release(buf);
705 else
706 cifs_buf_release(buf);
707 }
708
709 cifs_put_tlink(cfile->tlink);
710 kfree(file->private_data);
711 file->private_data = NULL;
712 /* BB can we lock the filestruct while this is going on? */
713 free_xid(xid);
714 return rc;
715 }
716
717 static struct cifsLockInfo *
718 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
719 {
720 struct cifsLockInfo *lock =
721 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
722 if (!lock)
723 return lock;
724 lock->offset = offset;
725 lock->length = length;
726 lock->type = type;
727 lock->pid = current->tgid;
728 INIT_LIST_HEAD(&lock->blist);
729 init_waitqueue_head(&lock->block_q);
730 return lock;
731 }
732
733 void
734 cifs_del_lock_waiters(struct cifsLockInfo *lock)
735 {
736 struct cifsLockInfo *li, *tmp;
737 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
738 list_del_init(&li->blist);
739 wake_up(&li->block_q);
740 }
741 }
742
743 static bool
744 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
745 __u64 length, __u8 type, struct cifsFileInfo *cfile,
746 struct cifsLockInfo **conf_lock, bool rw_check)
747 {
748 struct cifsLockInfo *li;
749 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
750 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
751
752 list_for_each_entry(li, &fdlocks->locks, llist) {
753 if (offset + length <= li->offset ||
754 offset >= li->offset + li->length)
755 continue;
756 if (rw_check && server->ops->compare_fids(cfile, cur_cfile) &&
757 current->tgid == li->pid)
758 continue;
759 if ((type & server->vals->shared_lock_type) &&
760 ((server->ops->compare_fids(cfile, cur_cfile) &&
761 current->tgid == li->pid) || type == li->type))
762 continue;
763 if (conf_lock)
764 *conf_lock = li;
765 return true;
766 }
767 return false;
768 }
769
770 bool
771 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
772 __u8 type, struct cifsLockInfo **conf_lock,
773 bool rw_check)
774 {
775 bool rc = false;
776 struct cifs_fid_locks *cur;
777 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
778
779 list_for_each_entry(cur, &cinode->llist, llist) {
780 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
781 cfile, conf_lock, rw_check);
782 if (rc)
783 break;
784 }
785
786 return rc;
787 }
788
789 /*
790 * Check if there is another lock that prevents us to set the lock (mandatory
791 * style). If such a lock exists, update the flock structure with its
792 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
793 * or leave it the same if we can't. Returns 0 if we don't need to request to
794 * the server or 1 otherwise.
795 */
796 static int
797 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
798 __u8 type, struct file_lock *flock)
799 {
800 int rc = 0;
801 struct cifsLockInfo *conf_lock;
802 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
803 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
804 bool exist;
805
806 down_read(&cinode->lock_sem);
807
808 exist = cifs_find_lock_conflict(cfile, offset, length, type,
809 &conf_lock, false);
810 if (exist) {
811 flock->fl_start = conf_lock->offset;
812 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
813 flock->fl_pid = conf_lock->pid;
814 if (conf_lock->type & server->vals->shared_lock_type)
815 flock->fl_type = F_RDLCK;
816 else
817 flock->fl_type = F_WRLCK;
818 } else if (!cinode->can_cache_brlcks)
819 rc = 1;
820 else
821 flock->fl_type = F_UNLCK;
822
823 up_read(&cinode->lock_sem);
824 return rc;
825 }
826
827 static void
828 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
829 {
830 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
831 down_write(&cinode->lock_sem);
832 list_add_tail(&lock->llist, &cfile->llist->locks);
833 up_write(&cinode->lock_sem);
834 }
835
836 /*
837 * Set the byte-range lock (mandatory style). Returns:
838 * 1) 0, if we set the lock and don't need to request to the server;
839 * 2) 1, if no locks prevent us but we need to request to the server;
840 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
841 */
842 static int
843 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
844 bool wait)
845 {
846 struct cifsLockInfo *conf_lock;
847 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
848 bool exist;
849 int rc = 0;
850
851 try_again:
852 exist = false;
853 down_write(&cinode->lock_sem);
854
855 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
856 lock->type, &conf_lock, false);
857 if (!exist && cinode->can_cache_brlcks) {
858 list_add_tail(&lock->llist, &cfile->llist->locks);
859 up_write(&cinode->lock_sem);
860 return rc;
861 }
862
863 if (!exist)
864 rc = 1;
865 else if (!wait)
866 rc = -EACCES;
867 else {
868 list_add_tail(&lock->blist, &conf_lock->blist);
869 up_write(&cinode->lock_sem);
870 rc = wait_event_interruptible(lock->block_q,
871 (lock->blist.prev == &lock->blist) &&
872 (lock->blist.next == &lock->blist));
873 if (!rc)
874 goto try_again;
875 down_write(&cinode->lock_sem);
876 list_del_init(&lock->blist);
877 }
878
879 up_write(&cinode->lock_sem);
880 return rc;
881 }
882
883 /*
884 * Check if there is another lock that prevents us to set the lock (posix
885 * style). If such a lock exists, update the flock structure with its
886 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
887 * or leave it the same if we can't. Returns 0 if we don't need to request to
888 * the server or 1 otherwise.
889 */
890 static int
891 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
892 {
893 int rc = 0;
894 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
895 unsigned char saved_type = flock->fl_type;
896
897 if ((flock->fl_flags & FL_POSIX) == 0)
898 return 1;
899
900 down_read(&cinode->lock_sem);
901 posix_test_lock(file, flock);
902
903 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
904 flock->fl_type = saved_type;
905 rc = 1;
906 }
907
908 up_read(&cinode->lock_sem);
909 return rc;
910 }
911
912 /*
913 * Set the byte-range lock (posix style). Returns:
914 * 1) 0, if we set the lock and don't need to request to the server;
915 * 2) 1, if we need to request to the server;
916 * 3) <0, if the error occurs while setting the lock.
917 */
918 static int
919 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
920 {
921 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
922 int rc = 1;
923
924 if ((flock->fl_flags & FL_POSIX) == 0)
925 return rc;
926
927 try_again:
928 down_write(&cinode->lock_sem);
929 if (!cinode->can_cache_brlcks) {
930 up_write(&cinode->lock_sem);
931 return rc;
932 }
933
934 rc = posix_lock_file(file, flock, NULL);
935 up_write(&cinode->lock_sem);
936 if (rc == FILE_LOCK_DEFERRED) {
937 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
938 if (!rc)
939 goto try_again;
940 locks_delete_block(flock);
941 }
942 return rc;
943 }
944
945 int
946 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
947 {
948 unsigned int xid;
949 int rc = 0, stored_rc;
950 struct cifsLockInfo *li, *tmp;
951 struct cifs_tcon *tcon;
952 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
953 unsigned int num, max_num, max_buf;
954 LOCKING_ANDX_RANGE *buf, *cur;
955 int types[] = {LOCKING_ANDX_LARGE_FILES,
956 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
957 int i;
958
959 xid = get_xid();
960 tcon = tlink_tcon(cfile->tlink);
961
962 /* we are going to update can_cache_brlcks here - need a write access */
963 down_write(&cinode->lock_sem);
964 if (!cinode->can_cache_brlcks) {
965 up_write(&cinode->lock_sem);
966 free_xid(xid);
967 return rc;
968 }
969
970 /*
971 * Accessing maxBuf is racy with cifs_reconnect - need to store value
972 * and check it for zero before using.
973 */
974 max_buf = tcon->ses->server->maxBuf;
975 if (!max_buf) {
976 up_write(&cinode->lock_sem);
977 free_xid(xid);
978 return -EINVAL;
979 }
980
981 max_num = (max_buf - sizeof(struct smb_hdr)) /
982 sizeof(LOCKING_ANDX_RANGE);
983 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
984 if (!buf) {
985 up_write(&cinode->lock_sem);
986 free_xid(xid);
987 return -ENOMEM;
988 }
989
990 for (i = 0; i < 2; i++) {
991 cur = buf;
992 num = 0;
993 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
994 if (li->type != types[i])
995 continue;
996 cur->Pid = cpu_to_le16(li->pid);
997 cur->LengthLow = cpu_to_le32((u32)li->length);
998 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
999 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1000 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1001 if (++num == max_num) {
1002 stored_rc = cifs_lockv(xid, tcon,
1003 cfile->fid.netfid,
1004 (__u8)li->type, 0, num,
1005 buf);
1006 if (stored_rc)
1007 rc = stored_rc;
1008 cur = buf;
1009 num = 0;
1010 } else
1011 cur++;
1012 }
1013
1014 if (num) {
1015 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1016 (__u8)types[i], 0, num, buf);
1017 if (stored_rc)
1018 rc = stored_rc;
1019 }
1020 }
1021
1022 cinode->can_cache_brlcks = false;
1023 up_write(&cinode->lock_sem);
1024
1025 kfree(buf);
1026 free_xid(xid);
1027 return rc;
1028 }
1029
1030 /* copied from fs/locks.c with a name change */
1031 #define cifs_for_each_lock(inode, lockp) \
1032 for (lockp = &inode->i_flock; *lockp != NULL; \
1033 lockp = &(*lockp)->fl_next)
1034
1035 struct lock_to_push {
1036 struct list_head llist;
1037 __u64 offset;
1038 __u64 length;
1039 __u32 pid;
1040 __u16 netfid;
1041 __u8 type;
1042 };
1043
1044 static int
1045 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1046 {
1047 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1048 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1049 struct file_lock *flock, **before;
1050 unsigned int count = 0, i = 0;
1051 int rc = 0, xid, type;
1052 struct list_head locks_to_send, *el;
1053 struct lock_to_push *lck, *tmp;
1054 __u64 length;
1055
1056 xid = get_xid();
1057
1058 /* we are going to update can_cache_brlcks here - need a write access */
1059 down_write(&cinode->lock_sem);
1060 if (!cinode->can_cache_brlcks) {
1061 up_write(&cinode->lock_sem);
1062 free_xid(xid);
1063 return rc;
1064 }
1065
1066 lock_flocks();
1067 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1068 if ((*before)->fl_flags & FL_POSIX)
1069 count++;
1070 }
1071 unlock_flocks();
1072
1073 INIT_LIST_HEAD(&locks_to_send);
1074
1075 /*
1076 * Allocating count locks is enough because no FL_POSIX locks can be
1077 * added to the list while we are holding cinode->lock_sem that
1078 * protects locking operations of this inode.
1079 */
1080 for (; i < count; i++) {
1081 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1082 if (!lck) {
1083 rc = -ENOMEM;
1084 goto err_out;
1085 }
1086 list_add_tail(&lck->llist, &locks_to_send);
1087 }
1088
1089 el = locks_to_send.next;
1090 lock_flocks();
1091 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1092 flock = *before;
1093 if ((flock->fl_flags & FL_POSIX) == 0)
1094 continue;
1095 if (el == &locks_to_send) {
1096 /*
1097 * The list ended. We don't have enough allocated
1098 * structures - something is really wrong.
1099 */
1100 cERROR(1, "Can't push all brlocks!");
1101 break;
1102 }
1103 length = 1 + flock->fl_end - flock->fl_start;
1104 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1105 type = CIFS_RDLCK;
1106 else
1107 type = CIFS_WRLCK;
1108 lck = list_entry(el, struct lock_to_push, llist);
1109 lck->pid = flock->fl_pid;
1110 lck->netfid = cfile->fid.netfid;
1111 lck->length = length;
1112 lck->type = type;
1113 lck->offset = flock->fl_start;
1114 el = el->next;
1115 }
1116 unlock_flocks();
1117
1118 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1119 int stored_rc;
1120
1121 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1122 lck->offset, lck->length, NULL,
1123 lck->type, 0);
1124 if (stored_rc)
1125 rc = stored_rc;
1126 list_del(&lck->llist);
1127 kfree(lck);
1128 }
1129
1130 out:
1131 cinode->can_cache_brlcks = false;
1132 up_write(&cinode->lock_sem);
1133
1134 free_xid(xid);
1135 return rc;
1136 err_out:
1137 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1138 list_del(&lck->llist);
1139 kfree(lck);
1140 }
1141 goto out;
1142 }
1143
1144 static int
1145 cifs_push_locks(struct cifsFileInfo *cfile)
1146 {
1147 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1148 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1149
1150 if (cap_unix(tcon->ses) &&
1151 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1152 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1153 return cifs_push_posix_locks(cfile);
1154
1155 return tcon->ses->server->ops->push_mand_locks(cfile);
1156 }
1157
1158 static void
1159 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1160 bool *wait_flag, struct TCP_Server_Info *server)
1161 {
1162 if (flock->fl_flags & FL_POSIX)
1163 cFYI(1, "Posix");
1164 if (flock->fl_flags & FL_FLOCK)
1165 cFYI(1, "Flock");
1166 if (flock->fl_flags & FL_SLEEP) {
1167 cFYI(1, "Blocking lock");
1168 *wait_flag = true;
1169 }
1170 if (flock->fl_flags & FL_ACCESS)
1171 cFYI(1, "Process suspended by mandatory locking - "
1172 "not implemented yet");
1173 if (flock->fl_flags & FL_LEASE)
1174 cFYI(1, "Lease on file - not implemented yet");
1175 if (flock->fl_flags &
1176 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1177 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1178 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1179
1180 *type = server->vals->large_lock_type;
1181 if (flock->fl_type == F_WRLCK) {
1182 cFYI(1, "F_WRLCK ");
1183 *type |= server->vals->exclusive_lock_type;
1184 *lock = 1;
1185 } else if (flock->fl_type == F_UNLCK) {
1186 cFYI(1, "F_UNLCK");
1187 *type |= server->vals->unlock_lock_type;
1188 *unlock = 1;
1189 /* Check if unlock includes more than one lock range */
1190 } else if (flock->fl_type == F_RDLCK) {
1191 cFYI(1, "F_RDLCK");
1192 *type |= server->vals->shared_lock_type;
1193 *lock = 1;
1194 } else if (flock->fl_type == F_EXLCK) {
1195 cFYI(1, "F_EXLCK");
1196 *type |= server->vals->exclusive_lock_type;
1197 *lock = 1;
1198 } else if (flock->fl_type == F_SHLCK) {
1199 cFYI(1, "F_SHLCK");
1200 *type |= server->vals->shared_lock_type;
1201 *lock = 1;
1202 } else
1203 cFYI(1, "Unknown type of lock");
1204 }
1205
1206 static int
1207 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1208 bool wait_flag, bool posix_lck, unsigned int xid)
1209 {
1210 int rc = 0;
1211 __u64 length = 1 + flock->fl_end - flock->fl_start;
1212 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1213 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1214 struct TCP_Server_Info *server = tcon->ses->server;
1215 __u16 netfid = cfile->fid.netfid;
1216
1217 if (posix_lck) {
1218 int posix_lock_type;
1219
1220 rc = cifs_posix_lock_test(file, flock);
1221 if (!rc)
1222 return rc;
1223
1224 if (type & server->vals->shared_lock_type)
1225 posix_lock_type = CIFS_RDLCK;
1226 else
1227 posix_lock_type = CIFS_WRLCK;
1228 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1229 flock->fl_start, length, flock,
1230 posix_lock_type, wait_flag);
1231 return rc;
1232 }
1233
1234 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1235 if (!rc)
1236 return rc;
1237
1238 /* BB we could chain these into one lock request BB */
1239 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1240 1, 0, false);
1241 if (rc == 0) {
1242 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1243 type, 0, 1, false);
1244 flock->fl_type = F_UNLCK;
1245 if (rc != 0)
1246 cERROR(1, "Error unlocking previously locked "
1247 "range %d during test of lock", rc);
1248 return 0;
1249 }
1250
1251 if (type & server->vals->shared_lock_type) {
1252 flock->fl_type = F_WRLCK;
1253 return 0;
1254 }
1255
1256 type &= ~server->vals->exclusive_lock_type;
1257
1258 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1259 type | server->vals->shared_lock_type,
1260 1, 0, false);
1261 if (rc == 0) {
1262 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1263 type | server->vals->shared_lock_type, 0, 1, false);
1264 flock->fl_type = F_RDLCK;
1265 if (rc != 0)
1266 cERROR(1, "Error unlocking previously locked "
1267 "range %d during test of lock", rc);
1268 } else
1269 flock->fl_type = F_WRLCK;
1270
1271 return 0;
1272 }
1273
1274 void
1275 cifs_move_llist(struct list_head *source, struct list_head *dest)
1276 {
1277 struct list_head *li, *tmp;
1278 list_for_each_safe(li, tmp, source)
1279 list_move(li, dest);
1280 }
1281
1282 void
1283 cifs_free_llist(struct list_head *llist)
1284 {
1285 struct cifsLockInfo *li, *tmp;
1286 list_for_each_entry_safe(li, tmp, llist, llist) {
1287 cifs_del_lock_waiters(li);
1288 list_del(&li->llist);
1289 kfree(li);
1290 }
1291 }
1292
1293 int
1294 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1295 unsigned int xid)
1296 {
1297 int rc = 0, stored_rc;
1298 int types[] = {LOCKING_ANDX_LARGE_FILES,
1299 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1300 unsigned int i;
1301 unsigned int max_num, num, max_buf;
1302 LOCKING_ANDX_RANGE *buf, *cur;
1303 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1304 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1305 struct cifsLockInfo *li, *tmp;
1306 __u64 length = 1 + flock->fl_end - flock->fl_start;
1307 struct list_head tmp_llist;
1308
1309 INIT_LIST_HEAD(&tmp_llist);
1310
1311 /*
1312 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1313 * and check it for zero before using.
1314 */
1315 max_buf = tcon->ses->server->maxBuf;
1316 if (!max_buf)
1317 return -EINVAL;
1318
1319 max_num = (max_buf - sizeof(struct smb_hdr)) /
1320 sizeof(LOCKING_ANDX_RANGE);
1321 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1322 if (!buf)
1323 return -ENOMEM;
1324
1325 down_write(&cinode->lock_sem);
1326 for (i = 0; i < 2; i++) {
1327 cur = buf;
1328 num = 0;
1329 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1330 if (flock->fl_start > li->offset ||
1331 (flock->fl_start + length) <
1332 (li->offset + li->length))
1333 continue;
1334 if (current->tgid != li->pid)
1335 continue;
1336 if (types[i] != li->type)
1337 continue;
1338 if (cinode->can_cache_brlcks) {
1339 /*
1340 * We can cache brlock requests - simply remove
1341 * a lock from the file's list.
1342 */
1343 list_del(&li->llist);
1344 cifs_del_lock_waiters(li);
1345 kfree(li);
1346 continue;
1347 }
1348 cur->Pid = cpu_to_le16(li->pid);
1349 cur->LengthLow = cpu_to_le32((u32)li->length);
1350 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1351 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1352 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1353 /*
1354 * We need to save a lock here to let us add it again to
1355 * the file's list if the unlock range request fails on
1356 * the server.
1357 */
1358 list_move(&li->llist, &tmp_llist);
1359 if (++num == max_num) {
1360 stored_rc = cifs_lockv(xid, tcon,
1361 cfile->fid.netfid,
1362 li->type, num, 0, buf);
1363 if (stored_rc) {
1364 /*
1365 * We failed on the unlock range
1366 * request - add all locks from the tmp
1367 * list to the head of the file's list.
1368 */
1369 cifs_move_llist(&tmp_llist,
1370 &cfile->llist->locks);
1371 rc = stored_rc;
1372 } else
1373 /*
1374 * The unlock range request succeed -
1375 * free the tmp list.
1376 */
1377 cifs_free_llist(&tmp_llist);
1378 cur = buf;
1379 num = 0;
1380 } else
1381 cur++;
1382 }
1383 if (num) {
1384 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1385 types[i], num, 0, buf);
1386 if (stored_rc) {
1387 cifs_move_llist(&tmp_llist,
1388 &cfile->llist->locks);
1389 rc = stored_rc;
1390 } else
1391 cifs_free_llist(&tmp_llist);
1392 }
1393 }
1394
1395 up_write(&cinode->lock_sem);
1396 kfree(buf);
1397 return rc;
1398 }
1399
1400 static int
1401 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1402 bool wait_flag, bool posix_lck, int lock, int unlock,
1403 unsigned int xid)
1404 {
1405 int rc = 0;
1406 __u64 length = 1 + flock->fl_end - flock->fl_start;
1407 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1408 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1409 struct TCP_Server_Info *server = tcon->ses->server;
1410
1411 if (posix_lck) {
1412 int posix_lock_type;
1413
1414 rc = cifs_posix_lock_set(file, flock);
1415 if (!rc || rc < 0)
1416 return rc;
1417
1418 if (type & server->vals->shared_lock_type)
1419 posix_lock_type = CIFS_RDLCK;
1420 else
1421 posix_lock_type = CIFS_WRLCK;
1422
1423 if (unlock == 1)
1424 posix_lock_type = CIFS_UNLCK;
1425
1426 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1427 current->tgid, flock->fl_start, length,
1428 NULL, posix_lock_type, wait_flag);
1429 goto out;
1430 }
1431
1432 if (lock) {
1433 struct cifsLockInfo *lock;
1434
1435 lock = cifs_lock_init(flock->fl_start, length, type);
1436 if (!lock)
1437 return -ENOMEM;
1438
1439 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1440 if (rc < 0)
1441 kfree(lock);
1442 if (rc <= 0)
1443 goto out;
1444
1445 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1446 type, 1, 0, wait_flag);
1447 if (rc) {
1448 kfree(lock);
1449 goto out;
1450 }
1451
1452 cifs_lock_add(cfile, lock);
1453 } else if (unlock)
1454 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1455
1456 out:
1457 if (flock->fl_flags & FL_POSIX)
1458 posix_lock_file_wait(file, flock);
1459 return rc;
1460 }
1461
1462 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1463 {
1464 int rc, xid;
1465 int lock = 0, unlock = 0;
1466 bool wait_flag = false;
1467 bool posix_lck = false;
1468 struct cifs_sb_info *cifs_sb;
1469 struct cifs_tcon *tcon;
1470 struct cifsInodeInfo *cinode;
1471 struct cifsFileInfo *cfile;
1472 __u16 netfid;
1473 __u32 type;
1474
1475 rc = -EACCES;
1476 xid = get_xid();
1477
1478 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1479 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1480 flock->fl_start, flock->fl_end);
1481
1482 cfile = (struct cifsFileInfo *)file->private_data;
1483 tcon = tlink_tcon(cfile->tlink);
1484
1485 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1486 tcon->ses->server);
1487
1488 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1489 netfid = cfile->fid.netfid;
1490 cinode = CIFS_I(file->f_path.dentry->d_inode);
1491
1492 if (cap_unix(tcon->ses) &&
1493 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1494 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1495 posix_lck = true;
1496 /*
1497 * BB add code here to normalize offset and length to account for
1498 * negative length which we can not accept over the wire.
1499 */
1500 if (IS_GETLK(cmd)) {
1501 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1502 free_xid(xid);
1503 return rc;
1504 }
1505
1506 if (!lock && !unlock) {
1507 /*
1508 * if no lock or unlock then nothing to do since we do not
1509 * know what it is
1510 */
1511 free_xid(xid);
1512 return -EOPNOTSUPP;
1513 }
1514
1515 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1516 xid);
1517 free_xid(xid);
1518 return rc;
1519 }
1520
1521 /*
1522 * update the file size (if needed) after a write. Should be called with
1523 * the inode->i_lock held
1524 */
1525 void
1526 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1527 unsigned int bytes_written)
1528 {
1529 loff_t end_of_write = offset + bytes_written;
1530
1531 if (end_of_write > cifsi->server_eof)
1532 cifsi->server_eof = end_of_write;
1533 }
1534
1535 static ssize_t
1536 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1537 size_t write_size, loff_t *offset)
1538 {
1539 int rc = 0;
1540 unsigned int bytes_written = 0;
1541 unsigned int total_written;
1542 struct cifs_sb_info *cifs_sb;
1543 struct cifs_tcon *tcon;
1544 struct TCP_Server_Info *server;
1545 unsigned int xid;
1546 struct dentry *dentry = open_file->dentry;
1547 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1548 struct cifs_io_parms io_parms;
1549
1550 cifs_sb = CIFS_SB(dentry->d_sb);
1551
1552 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1553 *offset, dentry->d_name.name);
1554
1555 tcon = tlink_tcon(open_file->tlink);
1556 server = tcon->ses->server;
1557
1558 if (!server->ops->sync_write)
1559 return -ENOSYS;
1560
1561 xid = get_xid();
1562
1563 for (total_written = 0; write_size > total_written;
1564 total_written += bytes_written) {
1565 rc = -EAGAIN;
1566 while (rc == -EAGAIN) {
1567 struct kvec iov[2];
1568 unsigned int len;
1569
1570 if (open_file->invalidHandle) {
1571 /* we could deadlock if we called
1572 filemap_fdatawait from here so tell
1573 reopen_file not to flush data to
1574 server now */
1575 rc = cifs_reopen_file(open_file, false);
1576 if (rc != 0)
1577 break;
1578 }
1579
1580 len = min((size_t)cifs_sb->wsize,
1581 write_size - total_written);
1582 /* iov[0] is reserved for smb header */
1583 iov[1].iov_base = (char *)write_data + total_written;
1584 iov[1].iov_len = len;
1585 io_parms.pid = pid;
1586 io_parms.tcon = tcon;
1587 io_parms.offset = *offset;
1588 io_parms.length = len;
1589 rc = server->ops->sync_write(xid, open_file, &io_parms,
1590 &bytes_written, iov, 1);
1591 }
1592 if (rc || (bytes_written == 0)) {
1593 if (total_written)
1594 break;
1595 else {
1596 free_xid(xid);
1597 return rc;
1598 }
1599 } else {
1600 spin_lock(&dentry->d_inode->i_lock);
1601 cifs_update_eof(cifsi, *offset, bytes_written);
1602 spin_unlock(&dentry->d_inode->i_lock);
1603 *offset += bytes_written;
1604 }
1605 }
1606
1607 cifs_stats_bytes_written(tcon, total_written);
1608
1609 if (total_written > 0) {
1610 spin_lock(&dentry->d_inode->i_lock);
1611 if (*offset > dentry->d_inode->i_size)
1612 i_size_write(dentry->d_inode, *offset);
1613 spin_unlock(&dentry->d_inode->i_lock);
1614 }
1615 mark_inode_dirty_sync(dentry->d_inode);
1616 free_xid(xid);
1617 return total_written;
1618 }
1619
1620 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1621 bool fsuid_only)
1622 {
1623 struct cifsFileInfo *open_file = NULL;
1624 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1625
1626 /* only filter by fsuid on multiuser mounts */
1627 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1628 fsuid_only = false;
1629
1630 spin_lock(&cifs_file_list_lock);
1631 /* we could simply get the first_list_entry since write-only entries
1632 are always at the end of the list but since the first entry might
1633 have a close pending, we go through the whole list */
1634 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1635 if (fsuid_only && open_file->uid != current_fsuid())
1636 continue;
1637 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1638 if (!open_file->invalidHandle) {
1639 /* found a good file */
1640 /* lock it so it will not be closed on us */
1641 cifsFileInfo_get_locked(open_file);
1642 spin_unlock(&cifs_file_list_lock);
1643 return open_file;
1644 } /* else might as well continue, and look for
1645 another, or simply have the caller reopen it
1646 again rather than trying to fix this handle */
1647 } else /* write only file */
1648 break; /* write only files are last so must be done */
1649 }
1650 spin_unlock(&cifs_file_list_lock);
1651 return NULL;
1652 }
1653
1654 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1655 bool fsuid_only)
1656 {
1657 struct cifsFileInfo *open_file, *inv_file = NULL;
1658 struct cifs_sb_info *cifs_sb;
1659 bool any_available = false;
1660 int rc;
1661 unsigned int refind = 0;
1662
1663 /* Having a null inode here (because mapping->host was set to zero by
1664 the VFS or MM) should not happen but we had reports of on oops (due to
1665 it being zero) during stress testcases so we need to check for it */
1666
1667 if (cifs_inode == NULL) {
1668 cERROR(1, "Null inode passed to cifs_writeable_file");
1669 dump_stack();
1670 return NULL;
1671 }
1672
1673 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1674
1675 /* only filter by fsuid on multiuser mounts */
1676 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1677 fsuid_only = false;
1678
1679 spin_lock(&cifs_file_list_lock);
1680 refind_writable:
1681 if (refind > MAX_REOPEN_ATT) {
1682 spin_unlock(&cifs_file_list_lock);
1683 return NULL;
1684 }
1685 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1686 if (!any_available && open_file->pid != current->tgid)
1687 continue;
1688 if (fsuid_only && open_file->uid != current_fsuid())
1689 continue;
1690 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1691 if (!open_file->invalidHandle) {
1692 /* found a good writable file */
1693 cifsFileInfo_get_locked(open_file);
1694 spin_unlock(&cifs_file_list_lock);
1695 return open_file;
1696 } else {
1697 if (!inv_file)
1698 inv_file = open_file;
1699 }
1700 }
1701 }
1702 /* couldn't find useable FH with same pid, try any available */
1703 if (!any_available) {
1704 any_available = true;
1705 goto refind_writable;
1706 }
1707
1708 if (inv_file) {
1709 any_available = false;
1710 cifsFileInfo_get_locked(inv_file);
1711 }
1712
1713 spin_unlock(&cifs_file_list_lock);
1714
1715 if (inv_file) {
1716 rc = cifs_reopen_file(inv_file, false);
1717 if (!rc)
1718 return inv_file;
1719 else {
1720 spin_lock(&cifs_file_list_lock);
1721 list_move_tail(&inv_file->flist,
1722 &cifs_inode->openFileList);
1723 spin_unlock(&cifs_file_list_lock);
1724 cifsFileInfo_put(inv_file);
1725 spin_lock(&cifs_file_list_lock);
1726 ++refind;
1727 goto refind_writable;
1728 }
1729 }
1730
1731 return NULL;
1732 }
1733
1734 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1735 {
1736 struct address_space *mapping = page->mapping;
1737 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1738 char *write_data;
1739 int rc = -EFAULT;
1740 int bytes_written = 0;
1741 struct inode *inode;
1742 struct cifsFileInfo *open_file;
1743
1744 if (!mapping || !mapping->host)
1745 return -EFAULT;
1746
1747 inode = page->mapping->host;
1748
1749 offset += (loff_t)from;
1750 write_data = kmap(page);
1751 write_data += from;
1752
1753 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1754 kunmap(page);
1755 return -EIO;
1756 }
1757
1758 /* racing with truncate? */
1759 if (offset > mapping->host->i_size) {
1760 kunmap(page);
1761 return 0; /* don't care */
1762 }
1763
1764 /* check to make sure that we are not extending the file */
1765 if (mapping->host->i_size - offset < (loff_t)to)
1766 to = (unsigned)(mapping->host->i_size - offset);
1767
1768 open_file = find_writable_file(CIFS_I(mapping->host), false);
1769 if (open_file) {
1770 bytes_written = cifs_write(open_file, open_file->pid,
1771 write_data, to - from, &offset);
1772 cifsFileInfo_put(open_file);
1773 /* Does mm or vfs already set times? */
1774 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1775 if ((bytes_written > 0) && (offset))
1776 rc = 0;
1777 else if (bytes_written < 0)
1778 rc = bytes_written;
1779 } else {
1780 cFYI(1, "No writeable filehandles for inode");
1781 rc = -EIO;
1782 }
1783
1784 kunmap(page);
1785 return rc;
1786 }
1787
1788 static int cifs_writepages(struct address_space *mapping,
1789 struct writeback_control *wbc)
1790 {
1791 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1792 bool done = false, scanned = false, range_whole = false;
1793 pgoff_t end, index;
1794 struct cifs_writedata *wdata;
1795 struct TCP_Server_Info *server;
1796 struct page *page;
1797 int rc = 0;
1798 loff_t isize = i_size_read(mapping->host);
1799
1800 /*
1801 * If wsize is smaller than the page cache size, default to writing
1802 * one page at a time via cifs_writepage
1803 */
1804 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1805 return generic_writepages(mapping, wbc);
1806
1807 if (wbc->range_cyclic) {
1808 index = mapping->writeback_index; /* Start from prev offset */
1809 end = -1;
1810 } else {
1811 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1812 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1813 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1814 range_whole = true;
1815 scanned = true;
1816 }
1817 retry:
1818 while (!done && index <= end) {
1819 unsigned int i, nr_pages, found_pages;
1820 pgoff_t next = 0, tofind;
1821 struct page **pages;
1822
1823 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1824 end - index) + 1;
1825
1826 wdata = cifs_writedata_alloc((unsigned int)tofind,
1827 cifs_writev_complete);
1828 if (!wdata) {
1829 rc = -ENOMEM;
1830 break;
1831 }
1832
1833 /*
1834 * find_get_pages_tag seems to return a max of 256 on each
1835 * iteration, so we must call it several times in order to
1836 * fill the array or the wsize is effectively limited to
1837 * 256 * PAGE_CACHE_SIZE.
1838 */
1839 found_pages = 0;
1840 pages = wdata->pages;
1841 do {
1842 nr_pages = find_get_pages_tag(mapping, &index,
1843 PAGECACHE_TAG_DIRTY,
1844 tofind, pages);
1845 found_pages += nr_pages;
1846 tofind -= nr_pages;
1847 pages += nr_pages;
1848 } while (nr_pages && tofind && index <= end);
1849
1850 if (found_pages == 0) {
1851 kref_put(&wdata->refcount, cifs_writedata_release);
1852 break;
1853 }
1854
1855 nr_pages = 0;
1856 for (i = 0; i < found_pages; i++) {
1857 page = wdata->pages[i];
1858 /*
1859 * At this point we hold neither mapping->tree_lock nor
1860 * lock on the page itself: the page may be truncated or
1861 * invalidated (changing page->mapping to NULL), or even
1862 * swizzled back from swapper_space to tmpfs file
1863 * mapping
1864 */
1865
1866 if (nr_pages == 0)
1867 lock_page(page);
1868 else if (!trylock_page(page))
1869 break;
1870
1871 if (unlikely(page->mapping != mapping)) {
1872 unlock_page(page);
1873 break;
1874 }
1875
1876 if (!wbc->range_cyclic && page->index > end) {
1877 done = true;
1878 unlock_page(page);
1879 break;
1880 }
1881
1882 if (next && (page->index != next)) {
1883 /* Not next consecutive page */
1884 unlock_page(page);
1885 break;
1886 }
1887
1888 if (wbc->sync_mode != WB_SYNC_NONE)
1889 wait_on_page_writeback(page);
1890
1891 if (PageWriteback(page) ||
1892 !clear_page_dirty_for_io(page)) {
1893 unlock_page(page);
1894 break;
1895 }
1896
1897 /*
1898 * This actually clears the dirty bit in the radix tree.
1899 * See cifs_writepage() for more commentary.
1900 */
1901 set_page_writeback(page);
1902
1903 if (page_offset(page) >= isize) {
1904 done = true;
1905 unlock_page(page);
1906 end_page_writeback(page);
1907 break;
1908 }
1909
1910 wdata->pages[i] = page;
1911 next = page->index + 1;
1912 ++nr_pages;
1913 }
1914
1915 /* reset index to refind any pages skipped */
1916 if (nr_pages == 0)
1917 index = wdata->pages[0]->index + 1;
1918
1919 /* put any pages we aren't going to use */
1920 for (i = nr_pages; i < found_pages; i++) {
1921 page_cache_release(wdata->pages[i]);
1922 wdata->pages[i] = NULL;
1923 }
1924
1925 /* nothing to write? */
1926 if (nr_pages == 0) {
1927 kref_put(&wdata->refcount, cifs_writedata_release);
1928 continue;
1929 }
1930
1931 wdata->sync_mode = wbc->sync_mode;
1932 wdata->nr_pages = nr_pages;
1933 wdata->offset = page_offset(wdata->pages[0]);
1934 wdata->pagesz = PAGE_CACHE_SIZE;
1935 wdata->tailsz =
1936 min(isize - page_offset(wdata->pages[nr_pages - 1]),
1937 (loff_t)PAGE_CACHE_SIZE);
1938 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
1939 wdata->tailsz;
1940
1941 do {
1942 if (wdata->cfile != NULL)
1943 cifsFileInfo_put(wdata->cfile);
1944 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1945 false);
1946 if (!wdata->cfile) {
1947 cERROR(1, "No writable handles for inode");
1948 rc = -EBADF;
1949 break;
1950 }
1951 wdata->pid = wdata->cfile->pid;
1952 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1953 rc = server->ops->async_writev(wdata);
1954 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1955
1956 for (i = 0; i < nr_pages; ++i)
1957 unlock_page(wdata->pages[i]);
1958
1959 /* send failure -- clean up the mess */
1960 if (rc != 0) {
1961 for (i = 0; i < nr_pages; ++i) {
1962 if (rc == -EAGAIN)
1963 redirty_page_for_writepage(wbc,
1964 wdata->pages[i]);
1965 else
1966 SetPageError(wdata->pages[i]);
1967 end_page_writeback(wdata->pages[i]);
1968 page_cache_release(wdata->pages[i]);
1969 }
1970 if (rc != -EAGAIN)
1971 mapping_set_error(mapping, rc);
1972 }
1973 kref_put(&wdata->refcount, cifs_writedata_release);
1974
1975 wbc->nr_to_write -= nr_pages;
1976 if (wbc->nr_to_write <= 0)
1977 done = true;
1978
1979 index = next;
1980 }
1981
1982 if (!scanned && !done) {
1983 /*
1984 * We hit the last page and there is more work to be done: wrap
1985 * back to the start of the file
1986 */
1987 scanned = true;
1988 index = 0;
1989 goto retry;
1990 }
1991
1992 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1993 mapping->writeback_index = index;
1994
1995 return rc;
1996 }
1997
1998 static int
1999 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2000 {
2001 int rc;
2002 unsigned int xid;
2003
2004 xid = get_xid();
2005 /* BB add check for wbc flags */
2006 page_cache_get(page);
2007 if (!PageUptodate(page))
2008 cFYI(1, "ppw - page not up to date");
2009
2010 /*
2011 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2012 *
2013 * A writepage() implementation always needs to do either this,
2014 * or re-dirty the page with "redirty_page_for_writepage()" in
2015 * the case of a failure.
2016 *
2017 * Just unlocking the page will cause the radix tree tag-bits
2018 * to fail to update with the state of the page correctly.
2019 */
2020 set_page_writeback(page);
2021 retry_write:
2022 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2023 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2024 goto retry_write;
2025 else if (rc == -EAGAIN)
2026 redirty_page_for_writepage(wbc, page);
2027 else if (rc != 0)
2028 SetPageError(page);
2029 else
2030 SetPageUptodate(page);
2031 end_page_writeback(page);
2032 page_cache_release(page);
2033 free_xid(xid);
2034 return rc;
2035 }
2036
2037 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2038 {
2039 int rc = cifs_writepage_locked(page, wbc);
2040 unlock_page(page);
2041 return rc;
2042 }
2043
2044 static int cifs_write_end(struct file *file, struct address_space *mapping,
2045 loff_t pos, unsigned len, unsigned copied,
2046 struct page *page, void *fsdata)
2047 {
2048 int rc;
2049 struct inode *inode = mapping->host;
2050 struct cifsFileInfo *cfile = file->private_data;
2051 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2052 __u32 pid;
2053
2054 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2055 pid = cfile->pid;
2056 else
2057 pid = current->tgid;
2058
2059 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2060 page, pos, copied);
2061
2062 if (PageChecked(page)) {
2063 if (copied == len)
2064 SetPageUptodate(page);
2065 ClearPageChecked(page);
2066 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2067 SetPageUptodate(page);
2068
2069 if (!PageUptodate(page)) {
2070 char *page_data;
2071 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2072 unsigned int xid;
2073
2074 xid = get_xid();
2075 /* this is probably better than directly calling
2076 partialpage_write since in this function the file handle is
2077 known which we might as well leverage */
2078 /* BB check if anything else missing out of ppw
2079 such as updating last write time */
2080 page_data = kmap(page);
2081 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2082 /* if (rc < 0) should we set writebehind rc? */
2083 kunmap(page);
2084
2085 free_xid(xid);
2086 } else {
2087 rc = copied;
2088 pos += copied;
2089 set_page_dirty(page);
2090 }
2091
2092 if (rc > 0) {
2093 spin_lock(&inode->i_lock);
2094 if (pos > inode->i_size)
2095 i_size_write(inode, pos);
2096 spin_unlock(&inode->i_lock);
2097 }
2098
2099 unlock_page(page);
2100 page_cache_release(page);
2101
2102 return rc;
2103 }
2104
2105 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2106 int datasync)
2107 {
2108 unsigned int xid;
2109 int rc = 0;
2110 struct cifs_tcon *tcon;
2111 struct TCP_Server_Info *server;
2112 struct cifsFileInfo *smbfile = file->private_data;
2113 struct inode *inode = file->f_path.dentry->d_inode;
2114 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2115
2116 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2117 if (rc)
2118 return rc;
2119 mutex_lock(&inode->i_mutex);
2120
2121 xid = get_xid();
2122
2123 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2124 file->f_path.dentry->d_name.name, datasync);
2125
2126 if (!CIFS_I(inode)->clientCanCacheRead) {
2127 rc = cifs_invalidate_mapping(inode);
2128 if (rc) {
2129 cFYI(1, "rc: %d during invalidate phase", rc);
2130 rc = 0; /* don't care about it in fsync */
2131 }
2132 }
2133
2134 tcon = tlink_tcon(smbfile->tlink);
2135 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2136 server = tcon->ses->server;
2137 if (server->ops->flush)
2138 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2139 else
2140 rc = -ENOSYS;
2141 }
2142
2143 free_xid(xid);
2144 mutex_unlock(&inode->i_mutex);
2145 return rc;
2146 }
2147
2148 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2149 {
2150 unsigned int xid;
2151 int rc = 0;
2152 struct cifs_tcon *tcon;
2153 struct TCP_Server_Info *server;
2154 struct cifsFileInfo *smbfile = file->private_data;
2155 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2156 struct inode *inode = file->f_mapping->host;
2157
2158 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2159 if (rc)
2160 return rc;
2161 mutex_lock(&inode->i_mutex);
2162
2163 xid = get_xid();
2164
2165 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2166 file->f_path.dentry->d_name.name, datasync);
2167
2168 tcon = tlink_tcon(smbfile->tlink);
2169 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2170 server = tcon->ses->server;
2171 if (server->ops->flush)
2172 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2173 else
2174 rc = -ENOSYS;
2175 }
2176
2177 free_xid(xid);
2178 mutex_unlock(&inode->i_mutex);
2179 return rc;
2180 }
2181
2182 /*
2183 * As file closes, flush all cached write data for this inode checking
2184 * for write behind errors.
2185 */
2186 int cifs_flush(struct file *file, fl_owner_t id)
2187 {
2188 struct inode *inode = file->f_path.dentry->d_inode;
2189 int rc = 0;
2190
2191 if (file->f_mode & FMODE_WRITE)
2192 rc = filemap_write_and_wait(inode->i_mapping);
2193
2194 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2195
2196 return rc;
2197 }
2198
2199 static int
2200 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2201 {
2202 int rc = 0;
2203 unsigned long i;
2204
2205 for (i = 0; i < num_pages; i++) {
2206 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2207 if (!pages[i]) {
2208 /*
2209 * save number of pages we have already allocated and
2210 * return with ENOMEM error
2211 */
2212 num_pages = i;
2213 rc = -ENOMEM;
2214 break;
2215 }
2216 }
2217
2218 if (rc) {
2219 for (i = 0; i < num_pages; i++)
2220 put_page(pages[i]);
2221 }
2222 return rc;
2223 }
2224
2225 static inline
2226 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2227 {
2228 size_t num_pages;
2229 size_t clen;
2230
2231 clen = min_t(const size_t, len, wsize);
2232 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2233
2234 if (cur_len)
2235 *cur_len = clen;
2236
2237 return num_pages;
2238 }
2239
2240 static void
2241 cifs_uncached_writev_complete(struct work_struct *work)
2242 {
2243 int i;
2244 struct cifs_writedata *wdata = container_of(work,
2245 struct cifs_writedata, work);
2246 struct inode *inode = wdata->cfile->dentry->d_inode;
2247 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2248
2249 spin_lock(&inode->i_lock);
2250 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2251 if (cifsi->server_eof > inode->i_size)
2252 i_size_write(inode, cifsi->server_eof);
2253 spin_unlock(&inode->i_lock);
2254
2255 complete(&wdata->done);
2256
2257 if (wdata->result != -EAGAIN) {
2258 for (i = 0; i < wdata->nr_pages; i++)
2259 put_page(wdata->pages[i]);
2260 }
2261
2262 kref_put(&wdata->refcount, cifs_writedata_release);
2263 }
2264
2265 /* attempt to send write to server, retry on any -EAGAIN errors */
2266 static int
2267 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2268 {
2269 int rc;
2270 struct TCP_Server_Info *server;
2271
2272 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2273
2274 do {
2275 if (wdata->cfile->invalidHandle) {
2276 rc = cifs_reopen_file(wdata->cfile, false);
2277 if (rc != 0)
2278 continue;
2279 }
2280 rc = server->ops->async_writev(wdata);
2281 } while (rc == -EAGAIN);
2282
2283 return rc;
2284 }
2285
2286 static ssize_t
2287 cifs_iovec_write(struct file *file, const struct iovec *iov,
2288 unsigned long nr_segs, loff_t *poffset)
2289 {
2290 unsigned long nr_pages, i;
2291 size_t copied, len, cur_len;
2292 ssize_t total_written = 0;
2293 loff_t offset;
2294 struct iov_iter it;
2295 struct cifsFileInfo *open_file;
2296 struct cifs_tcon *tcon;
2297 struct cifs_sb_info *cifs_sb;
2298 struct cifs_writedata *wdata, *tmp;
2299 struct list_head wdata_list;
2300 int rc;
2301 pid_t pid;
2302
2303 len = iov_length(iov, nr_segs);
2304 if (!len)
2305 return 0;
2306
2307 rc = generic_write_checks(file, poffset, &len, 0);
2308 if (rc)
2309 return rc;
2310
2311 INIT_LIST_HEAD(&wdata_list);
2312 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2313 open_file = file->private_data;
2314 tcon = tlink_tcon(open_file->tlink);
2315
2316 if (!tcon->ses->server->ops->async_writev)
2317 return -ENOSYS;
2318
2319 offset = *poffset;
2320
2321 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2322 pid = open_file->pid;
2323 else
2324 pid = current->tgid;
2325
2326 iov_iter_init(&it, iov, nr_segs, len, 0);
2327 do {
2328 size_t save_len;
2329
2330 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2331 wdata = cifs_writedata_alloc(nr_pages,
2332 cifs_uncached_writev_complete);
2333 if (!wdata) {
2334 rc = -ENOMEM;
2335 break;
2336 }
2337
2338 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2339 if (rc) {
2340 kfree(wdata);
2341 break;
2342 }
2343
2344 save_len = cur_len;
2345 for (i = 0; i < nr_pages; i++) {
2346 copied = min_t(const size_t, cur_len, PAGE_SIZE);
2347 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2348 0, copied);
2349 cur_len -= copied;
2350 iov_iter_advance(&it, copied);
2351 }
2352 cur_len = save_len - cur_len;
2353
2354 wdata->sync_mode = WB_SYNC_ALL;
2355 wdata->nr_pages = nr_pages;
2356 wdata->offset = (__u64)offset;
2357 wdata->cfile = cifsFileInfo_get(open_file);
2358 wdata->pid = pid;
2359 wdata->bytes = cur_len;
2360 wdata->pagesz = PAGE_SIZE;
2361 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2362 rc = cifs_uncached_retry_writev(wdata);
2363 if (rc) {
2364 kref_put(&wdata->refcount, cifs_writedata_release);
2365 break;
2366 }
2367
2368 list_add_tail(&wdata->list, &wdata_list);
2369 offset += cur_len;
2370 len -= cur_len;
2371 } while (len > 0);
2372
2373 /*
2374 * If at least one write was successfully sent, then discard any rc
2375 * value from the later writes. If the other write succeeds, then
2376 * we'll end up returning whatever was written. If it fails, then
2377 * we'll get a new rc value from that.
2378 */
2379 if (!list_empty(&wdata_list))
2380 rc = 0;
2381
2382 /*
2383 * Wait for and collect replies for any successful sends in order of
2384 * increasing offset. Once an error is hit or we get a fatal signal
2385 * while waiting, then return without waiting for any more replies.
2386 */
2387 restart_loop:
2388 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2389 if (!rc) {
2390 /* FIXME: freezable too? */
2391 rc = wait_for_completion_killable(&wdata->done);
2392 if (rc)
2393 rc = -EINTR;
2394 else if (wdata->result)
2395 rc = wdata->result;
2396 else
2397 total_written += wdata->bytes;
2398
2399 /* resend call if it's a retryable error */
2400 if (rc == -EAGAIN) {
2401 rc = cifs_uncached_retry_writev(wdata);
2402 goto restart_loop;
2403 }
2404 }
2405 list_del_init(&wdata->list);
2406 kref_put(&wdata->refcount, cifs_writedata_release);
2407 }
2408
2409 if (total_written > 0)
2410 *poffset += total_written;
2411
2412 cifs_stats_bytes_written(tcon, total_written);
2413 return total_written ? total_written : (ssize_t)rc;
2414 }
2415
2416 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2417 unsigned long nr_segs, loff_t pos)
2418 {
2419 ssize_t written;
2420 struct inode *inode;
2421
2422 inode = iocb->ki_filp->f_path.dentry->d_inode;
2423
2424 /*
2425 * BB - optimize the way when signing is disabled. We can drop this
2426 * extra memory-to-memory copying and use iovec buffers for constructing
2427 * write request.
2428 */
2429
2430 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2431 if (written > 0) {
2432 CIFS_I(inode)->invalid_mapping = true;
2433 iocb->ki_pos = pos;
2434 }
2435
2436 return written;
2437 }
2438
2439 static ssize_t
2440 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2441 unsigned long nr_segs, loff_t pos)
2442 {
2443 struct file *file = iocb->ki_filp;
2444 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2445 struct inode *inode = file->f_mapping->host;
2446 struct cifsInodeInfo *cinode = CIFS_I(inode);
2447 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2448 ssize_t rc = -EACCES;
2449
2450 BUG_ON(iocb->ki_pos != pos);
2451
2452 sb_start_write(inode->i_sb);
2453
2454 /*
2455 * We need to hold the sem to be sure nobody modifies lock list
2456 * with a brlock that prevents writing.
2457 */
2458 down_read(&cinode->lock_sem);
2459 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2460 server->vals->exclusive_lock_type, NULL,
2461 true)) {
2462 mutex_lock(&inode->i_mutex);
2463 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2464 &iocb->ki_pos);
2465 mutex_unlock(&inode->i_mutex);
2466 }
2467
2468 if (rc > 0 || rc == -EIOCBQUEUED) {
2469 ssize_t err;
2470
2471 err = generic_write_sync(file, pos, rc);
2472 if (err < 0 && rc > 0)
2473 rc = err;
2474 }
2475
2476 up_read(&cinode->lock_sem);
2477 sb_end_write(inode->i_sb);
2478 return rc;
2479 }
2480
2481 ssize_t
2482 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2483 unsigned long nr_segs, loff_t pos)
2484 {
2485 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2486 struct cifsInodeInfo *cinode = CIFS_I(inode);
2487 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2488 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2489 iocb->ki_filp->private_data;
2490 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2491
2492 #ifdef CONFIG_CIFS_SMB2
2493 /*
2494 * If we have an oplock for read and want to write a data to the file
2495 * we need to store it in the page cache and then push it to the server
2496 * to be sure the next read will get a valid data.
2497 */
2498 if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead) {
2499 ssize_t written;
2500 int rc;
2501
2502 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
2503 rc = filemap_fdatawrite(inode->i_mapping);
2504 if (rc)
2505 return (ssize_t)rc;
2506
2507 return written;
2508 }
2509 #endif
2510
2511 /*
2512 * For non-oplocked files in strict cache mode we need to write the data
2513 * to the server exactly from the pos to pos+len-1 rather than flush all
2514 * affected pages because it may cause a error with mandatory locks on
2515 * these pages but not on the region from pos to ppos+len-1.
2516 */
2517
2518 if (!cinode->clientCanCacheAll)
2519 return cifs_user_writev(iocb, iov, nr_segs, pos);
2520
2521 if (cap_unix(tcon->ses) &&
2522 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2523 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2524 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2525
2526 return cifs_writev(iocb, iov, nr_segs, pos);
2527 }
2528
2529 static struct cifs_readdata *
2530 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2531 {
2532 struct cifs_readdata *rdata;
2533
2534 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2535 GFP_KERNEL);
2536 if (rdata != NULL) {
2537 kref_init(&rdata->refcount);
2538 INIT_LIST_HEAD(&rdata->list);
2539 init_completion(&rdata->done);
2540 INIT_WORK(&rdata->work, complete);
2541 }
2542
2543 return rdata;
2544 }
2545
2546 void
2547 cifs_readdata_release(struct kref *refcount)
2548 {
2549 struct cifs_readdata *rdata = container_of(refcount,
2550 struct cifs_readdata, refcount);
2551
2552 if (rdata->cfile)
2553 cifsFileInfo_put(rdata->cfile);
2554
2555 kfree(rdata);
2556 }
2557
2558 static int
2559 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2560 {
2561 int rc = 0;
2562 struct page *page;
2563 unsigned int i;
2564
2565 for (i = 0; i < nr_pages; i++) {
2566 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2567 if (!page) {
2568 rc = -ENOMEM;
2569 break;
2570 }
2571 rdata->pages[i] = page;
2572 }
2573
2574 if (rc) {
2575 for (i = 0; i < nr_pages; i++) {
2576 put_page(rdata->pages[i]);
2577 rdata->pages[i] = NULL;
2578 }
2579 }
2580 return rc;
2581 }
2582
2583 static void
2584 cifs_uncached_readdata_release(struct kref *refcount)
2585 {
2586 struct cifs_readdata *rdata = container_of(refcount,
2587 struct cifs_readdata, refcount);
2588 unsigned int i;
2589
2590 for (i = 0; i < rdata->nr_pages; i++) {
2591 put_page(rdata->pages[i]);
2592 rdata->pages[i] = NULL;
2593 }
2594 cifs_readdata_release(refcount);
2595 }
2596
2597 static int
2598 cifs_retry_async_readv(struct cifs_readdata *rdata)
2599 {
2600 int rc;
2601 struct TCP_Server_Info *server;
2602
2603 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2604
2605 do {
2606 if (rdata->cfile->invalidHandle) {
2607 rc = cifs_reopen_file(rdata->cfile, true);
2608 if (rc != 0)
2609 continue;
2610 }
2611 rc = server->ops->async_readv(rdata);
2612 } while (rc == -EAGAIN);
2613
2614 return rc;
2615 }
2616
2617 /**
2618 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2619 * @rdata: the readdata response with list of pages holding data
2620 * @iov: vector in which we should copy the data
2621 * @nr_segs: number of segments in vector
2622 * @offset: offset into file of the first iovec
2623 * @copied: used to return the amount of data copied to the iov
2624 *
2625 * This function copies data from a list of pages in a readdata response into
2626 * an array of iovecs. It will first calculate where the data should go
2627 * based on the info in the readdata and then copy the data into that spot.
2628 */
2629 static ssize_t
2630 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2631 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2632 {
2633 int rc = 0;
2634 struct iov_iter ii;
2635 size_t pos = rdata->offset - offset;
2636 ssize_t remaining = rdata->bytes;
2637 unsigned char *pdata;
2638 unsigned int i;
2639
2640 /* set up iov_iter and advance to the correct offset */
2641 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2642 iov_iter_advance(&ii, pos);
2643
2644 *copied = 0;
2645 for (i = 0; i < rdata->nr_pages; i++) {
2646 ssize_t copy;
2647 struct page *page = rdata->pages[i];
2648
2649 /* copy a whole page or whatever's left */
2650 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2651
2652 /* ...but limit it to whatever space is left in the iov */
2653 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2654
2655 /* go while there's data to be copied and no errors */
2656 if (copy && !rc) {
2657 pdata = kmap(page);
2658 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2659 (int)copy);
2660 kunmap(page);
2661 if (!rc) {
2662 *copied += copy;
2663 remaining -= copy;
2664 iov_iter_advance(&ii, copy);
2665 }
2666 }
2667 }
2668
2669 return rc;
2670 }
2671
2672 static void
2673 cifs_uncached_readv_complete(struct work_struct *work)
2674 {
2675 struct cifs_readdata *rdata = container_of(work,
2676 struct cifs_readdata, work);
2677
2678 complete(&rdata->done);
2679 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2680 }
2681
2682 static int
2683 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2684 struct cifs_readdata *rdata, unsigned int len)
2685 {
2686 int total_read = 0, result = 0;
2687 unsigned int i;
2688 unsigned int nr_pages = rdata->nr_pages;
2689 struct kvec iov;
2690
2691 rdata->tailsz = PAGE_SIZE;
2692 for (i = 0; i < nr_pages; i++) {
2693 struct page *page = rdata->pages[i];
2694
2695 if (len >= PAGE_SIZE) {
2696 /* enough data to fill the page */
2697 iov.iov_base = kmap(page);
2698 iov.iov_len = PAGE_SIZE;
2699 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2700 i, iov.iov_base, iov.iov_len);
2701 len -= PAGE_SIZE;
2702 } else if (len > 0) {
2703 /* enough for partial page, fill and zero the rest */
2704 iov.iov_base = kmap(page);
2705 iov.iov_len = len;
2706 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2707 i, iov.iov_base, iov.iov_len);
2708 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2709 rdata->tailsz = len;
2710 len = 0;
2711 } else {
2712 /* no need to hold page hostage */
2713 rdata->pages[i] = NULL;
2714 rdata->nr_pages--;
2715 put_page(page);
2716 continue;
2717 }
2718
2719 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2720 kunmap(page);
2721 if (result < 0)
2722 break;
2723
2724 total_read += result;
2725 }
2726
2727 return total_read > 0 ? total_read : result;
2728 }
2729
2730 static ssize_t
2731 cifs_iovec_read(struct file *file, const struct iovec *iov,
2732 unsigned long nr_segs, loff_t *poffset)
2733 {
2734 ssize_t rc;
2735 size_t len, cur_len;
2736 ssize_t total_read = 0;
2737 loff_t offset = *poffset;
2738 unsigned int npages;
2739 struct cifs_sb_info *cifs_sb;
2740 struct cifs_tcon *tcon;
2741 struct cifsFileInfo *open_file;
2742 struct cifs_readdata *rdata, *tmp;
2743 struct list_head rdata_list;
2744 pid_t pid;
2745
2746 if (!nr_segs)
2747 return 0;
2748
2749 len = iov_length(iov, nr_segs);
2750 if (!len)
2751 return 0;
2752
2753 INIT_LIST_HEAD(&rdata_list);
2754 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2755 open_file = file->private_data;
2756 tcon = tlink_tcon(open_file->tlink);
2757
2758 if (!tcon->ses->server->ops->async_readv)
2759 return -ENOSYS;
2760
2761 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2762 pid = open_file->pid;
2763 else
2764 pid = current->tgid;
2765
2766 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2767 cFYI(1, "attempting read on write only file instance");
2768
2769 do {
2770 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2771 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2772
2773 /* allocate a readdata struct */
2774 rdata = cifs_readdata_alloc(npages,
2775 cifs_uncached_readv_complete);
2776 if (!rdata) {
2777 rc = -ENOMEM;
2778 goto error;
2779 }
2780
2781 rc = cifs_read_allocate_pages(rdata, npages);
2782 if (rc)
2783 goto error;
2784
2785 rdata->cfile = cifsFileInfo_get(open_file);
2786 rdata->nr_pages = npages;
2787 rdata->offset = offset;
2788 rdata->bytes = cur_len;
2789 rdata->pid = pid;
2790 rdata->pagesz = PAGE_SIZE;
2791 rdata->read_into_pages = cifs_uncached_read_into_pages;
2792
2793 rc = cifs_retry_async_readv(rdata);
2794 error:
2795 if (rc) {
2796 kref_put(&rdata->refcount,
2797 cifs_uncached_readdata_release);
2798 break;
2799 }
2800
2801 list_add_tail(&rdata->list, &rdata_list);
2802 offset += cur_len;
2803 len -= cur_len;
2804 } while (len > 0);
2805
2806 /* if at least one read request send succeeded, then reset rc */
2807 if (!list_empty(&rdata_list))
2808 rc = 0;
2809
2810 /* the loop below should proceed in the order of increasing offsets */
2811 restart_loop:
2812 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2813 if (!rc) {
2814 ssize_t copied;
2815
2816 /* FIXME: freezable sleep too? */
2817 rc = wait_for_completion_killable(&rdata->done);
2818 if (rc)
2819 rc = -EINTR;
2820 else if (rdata->result)
2821 rc = rdata->result;
2822 else {
2823 rc = cifs_readdata_to_iov(rdata, iov,
2824 nr_segs, *poffset,
2825 &copied);
2826 total_read += copied;
2827 }
2828
2829 /* resend call if it's a retryable error */
2830 if (rc == -EAGAIN) {
2831 rc = cifs_retry_async_readv(rdata);
2832 goto restart_loop;
2833 }
2834 }
2835 list_del_init(&rdata->list);
2836 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2837 }
2838
2839 cifs_stats_bytes_read(tcon, total_read);
2840 *poffset += total_read;
2841
2842 /* mask nodata case */
2843 if (rc == -ENODATA)
2844 rc = 0;
2845
2846 return total_read ? total_read : rc;
2847 }
2848
2849 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2850 unsigned long nr_segs, loff_t pos)
2851 {
2852 ssize_t read;
2853
2854 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2855 if (read > 0)
2856 iocb->ki_pos = pos;
2857
2858 return read;
2859 }
2860
2861 ssize_t
2862 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2863 unsigned long nr_segs, loff_t pos)
2864 {
2865 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2866 struct cifsInodeInfo *cinode = CIFS_I(inode);
2867 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2868 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2869 iocb->ki_filp->private_data;
2870 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2871 int rc = -EACCES;
2872
2873 /*
2874 * In strict cache mode we need to read from the server all the time
2875 * if we don't have level II oplock because the server can delay mtime
2876 * change - so we can't make a decision about inode invalidating.
2877 * And we can also fail with pagereading if there are mandatory locks
2878 * on pages affected by this read but not on the region from pos to
2879 * pos+len-1.
2880 */
2881 if (!cinode->clientCanCacheRead)
2882 return cifs_user_readv(iocb, iov, nr_segs, pos);
2883
2884 if (cap_unix(tcon->ses) &&
2885 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2886 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2887 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2888
2889 /*
2890 * We need to hold the sem to be sure nobody modifies lock list
2891 * with a brlock that prevents reading.
2892 */
2893 down_read(&cinode->lock_sem);
2894 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2895 tcon->ses->server->vals->shared_lock_type,
2896 NULL, true))
2897 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2898 up_read(&cinode->lock_sem);
2899 return rc;
2900 }
2901
2902 static ssize_t
2903 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2904 {
2905 int rc = -EACCES;
2906 unsigned int bytes_read = 0;
2907 unsigned int total_read;
2908 unsigned int current_read_size;
2909 unsigned int rsize;
2910 struct cifs_sb_info *cifs_sb;
2911 struct cifs_tcon *tcon;
2912 struct TCP_Server_Info *server;
2913 unsigned int xid;
2914 char *cur_offset;
2915 struct cifsFileInfo *open_file;
2916 struct cifs_io_parms io_parms;
2917 int buf_type = CIFS_NO_BUFFER;
2918 __u32 pid;
2919
2920 xid = get_xid();
2921 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2922
2923 /* FIXME: set up handlers for larger reads and/or convert to async */
2924 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2925
2926 if (file->private_data == NULL) {
2927 rc = -EBADF;
2928 free_xid(xid);
2929 return rc;
2930 }
2931 open_file = file->private_data;
2932 tcon = tlink_tcon(open_file->tlink);
2933 server = tcon->ses->server;
2934
2935 if (!server->ops->sync_read) {
2936 free_xid(xid);
2937 return -ENOSYS;
2938 }
2939
2940 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2941 pid = open_file->pid;
2942 else
2943 pid = current->tgid;
2944
2945 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2946 cFYI(1, "attempting read on write only file instance");
2947
2948 for (total_read = 0, cur_offset = read_data; read_size > total_read;
2949 total_read += bytes_read, cur_offset += bytes_read) {
2950 current_read_size = min_t(uint, read_size - total_read, rsize);
2951 /*
2952 * For windows me and 9x we do not want to request more than it
2953 * negotiated since it will refuse the read then.
2954 */
2955 if ((tcon->ses) && !(tcon->ses->capabilities &
2956 tcon->ses->server->vals->cap_large_files)) {
2957 current_read_size = min_t(uint, current_read_size,
2958 CIFSMaxBufSize);
2959 }
2960 rc = -EAGAIN;
2961 while (rc == -EAGAIN) {
2962 if (open_file->invalidHandle) {
2963 rc = cifs_reopen_file(open_file, true);
2964 if (rc != 0)
2965 break;
2966 }
2967 io_parms.pid = pid;
2968 io_parms.tcon = tcon;
2969 io_parms.offset = *offset;
2970 io_parms.length = current_read_size;
2971 rc = server->ops->sync_read(xid, open_file, &io_parms,
2972 &bytes_read, &cur_offset,
2973 &buf_type);
2974 }
2975 if (rc || (bytes_read == 0)) {
2976 if (total_read) {
2977 break;
2978 } else {
2979 free_xid(xid);
2980 return rc;
2981 }
2982 } else {
2983 cifs_stats_bytes_read(tcon, total_read);
2984 *offset += bytes_read;
2985 }
2986 }
2987 free_xid(xid);
2988 return total_read;
2989 }
2990
2991 /*
2992 * If the page is mmap'ed into a process' page tables, then we need to make
2993 * sure that it doesn't change while being written back.
2994 */
2995 static int
2996 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2997 {
2998 struct page *page = vmf->page;
2999
3000 lock_page(page);
3001 return VM_FAULT_LOCKED;
3002 }
3003
3004 static struct vm_operations_struct cifs_file_vm_ops = {
3005 .fault = filemap_fault,
3006 .page_mkwrite = cifs_page_mkwrite,
3007 };
3008
3009 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3010 {
3011 int rc, xid;
3012 struct inode *inode = file->f_path.dentry->d_inode;
3013
3014 xid = get_xid();
3015
3016 if (!CIFS_I(inode)->clientCanCacheRead) {
3017 rc = cifs_invalidate_mapping(inode);
3018 if (rc)
3019 return rc;
3020 }
3021
3022 rc = generic_file_mmap(file, vma);
3023 if (rc == 0)
3024 vma->vm_ops = &cifs_file_vm_ops;
3025 free_xid(xid);
3026 return rc;
3027 }
3028
3029 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3030 {
3031 int rc, xid;
3032
3033 xid = get_xid();
3034 rc = cifs_revalidate_file(file);
3035 if (rc) {
3036 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
3037 free_xid(xid);
3038 return rc;
3039 }
3040 rc = generic_file_mmap(file, vma);
3041 if (rc == 0)
3042 vma->vm_ops = &cifs_file_vm_ops;
3043 free_xid(xid);
3044 return rc;
3045 }
3046
3047 static void
3048 cifs_readv_complete(struct work_struct *work)
3049 {
3050 unsigned int i;
3051 struct cifs_readdata *rdata = container_of(work,
3052 struct cifs_readdata, work);
3053
3054 for (i = 0; i < rdata->nr_pages; i++) {
3055 struct page *page = rdata->pages[i];
3056
3057 lru_cache_add_file(page);
3058
3059 if (rdata->result == 0) {
3060 flush_dcache_page(page);
3061 SetPageUptodate(page);
3062 }
3063
3064 unlock_page(page);
3065
3066 if (rdata->result == 0)
3067 cifs_readpage_to_fscache(rdata->mapping->host, page);
3068
3069 page_cache_release(page);
3070 rdata->pages[i] = NULL;
3071 }
3072 kref_put(&rdata->refcount, cifs_readdata_release);
3073 }
3074
3075 static int
3076 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3077 struct cifs_readdata *rdata, unsigned int len)
3078 {
3079 int total_read = 0, result = 0;
3080 unsigned int i;
3081 u64 eof;
3082 pgoff_t eof_index;
3083 unsigned int nr_pages = rdata->nr_pages;
3084 struct kvec iov;
3085
3086 /* determine the eof that the server (probably) has */
3087 eof = CIFS_I(rdata->mapping->host)->server_eof;
3088 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3089 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
3090
3091 rdata->tailsz = PAGE_CACHE_SIZE;
3092 for (i = 0; i < nr_pages; i++) {
3093 struct page *page = rdata->pages[i];
3094
3095 if (len >= PAGE_CACHE_SIZE) {
3096 /* enough data to fill the page */
3097 iov.iov_base = kmap(page);
3098 iov.iov_len = PAGE_CACHE_SIZE;
3099 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3100 i, page->index, iov.iov_base, iov.iov_len);
3101 len -= PAGE_CACHE_SIZE;
3102 } else if (len > 0) {
3103 /* enough for partial page, fill and zero the rest */
3104 iov.iov_base = kmap(page);
3105 iov.iov_len = len;
3106 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3107 i, page->index, iov.iov_base, iov.iov_len);
3108 memset(iov.iov_base + len,
3109 '\0', PAGE_CACHE_SIZE - len);
3110 rdata->tailsz = len;
3111 len = 0;
3112 } else if (page->index > eof_index) {
3113 /*
3114 * The VFS will not try to do readahead past the
3115 * i_size, but it's possible that we have outstanding
3116 * writes with gaps in the middle and the i_size hasn't
3117 * caught up yet. Populate those with zeroed out pages
3118 * to prevent the VFS from repeatedly attempting to
3119 * fill them until the writes are flushed.
3120 */
3121 zero_user(page, 0, PAGE_CACHE_SIZE);
3122 lru_cache_add_file(page);
3123 flush_dcache_page(page);
3124 SetPageUptodate(page);
3125 unlock_page(page);
3126 page_cache_release(page);
3127 rdata->pages[i] = NULL;
3128 rdata->nr_pages--;
3129 continue;
3130 } else {
3131 /* no need to hold page hostage */
3132 lru_cache_add_file(page);
3133 unlock_page(page);
3134 page_cache_release(page);
3135 rdata->pages[i] = NULL;
3136 rdata->nr_pages--;
3137 continue;
3138 }
3139
3140 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3141 kunmap(page);
3142 if (result < 0)
3143 break;
3144
3145 total_read += result;
3146 }
3147
3148 return total_read > 0 ? total_read : result;
3149 }
3150
3151 static int cifs_readpages(struct file *file, struct address_space *mapping,
3152 struct list_head *page_list, unsigned num_pages)
3153 {
3154 int rc;
3155 struct list_head tmplist;
3156 struct cifsFileInfo *open_file = file->private_data;
3157 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3158 unsigned int rsize = cifs_sb->rsize;
3159 pid_t pid;
3160
3161 /*
3162 * Give up immediately if rsize is too small to read an entire page.
3163 * The VFS will fall back to readpage. We should never reach this
3164 * point however since we set ra_pages to 0 when the rsize is smaller
3165 * than a cache page.
3166 */
3167 if (unlikely(rsize < PAGE_CACHE_SIZE))
3168 return 0;
3169
3170 /*
3171 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3172 * immediately if the cookie is negative
3173 */
3174 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3175 &num_pages);
3176 if (rc == 0)
3177 return rc;
3178
3179 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3180 pid = open_file->pid;
3181 else
3182 pid = current->tgid;
3183
3184 rc = 0;
3185 INIT_LIST_HEAD(&tmplist);
3186
3187 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
3188 mapping, num_pages);
3189
3190 /*
3191 * Start with the page at end of list and move it to private
3192 * list. Do the same with any following pages until we hit
3193 * the rsize limit, hit an index discontinuity, or run out of
3194 * pages. Issue the async read and then start the loop again
3195 * until the list is empty.
3196 *
3197 * Note that list order is important. The page_list is in
3198 * the order of declining indexes. When we put the pages in
3199 * the rdata->pages, then we want them in increasing order.
3200 */
3201 while (!list_empty(page_list)) {
3202 unsigned int i;
3203 unsigned int bytes = PAGE_CACHE_SIZE;
3204 unsigned int expected_index;
3205 unsigned int nr_pages = 1;
3206 loff_t offset;
3207 struct page *page, *tpage;
3208 struct cifs_readdata *rdata;
3209
3210 page = list_entry(page_list->prev, struct page, lru);
3211
3212 /*
3213 * Lock the page and put it in the cache. Since no one else
3214 * should have access to this page, we're safe to simply set
3215 * PG_locked without checking it first.
3216 */
3217 __set_page_locked(page);
3218 rc = add_to_page_cache_locked(page, mapping,
3219 page->index, GFP_KERNEL);
3220
3221 /* give up if we can't stick it in the cache */
3222 if (rc) {
3223 __clear_page_locked(page);
3224 break;
3225 }
3226
3227 /* move first page to the tmplist */
3228 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3229 list_move_tail(&page->lru, &tmplist);
3230
3231 /* now try and add more pages onto the request */
3232 expected_index = page->index + 1;
3233 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3234 /* discontinuity ? */
3235 if (page->index != expected_index)
3236 break;
3237
3238 /* would this page push the read over the rsize? */
3239 if (bytes + PAGE_CACHE_SIZE > rsize)
3240 break;
3241
3242 __set_page_locked(page);
3243 if (add_to_page_cache_locked(page, mapping,
3244 page->index, GFP_KERNEL)) {
3245 __clear_page_locked(page);
3246 break;
3247 }
3248 list_move_tail(&page->lru, &tmplist);
3249 bytes += PAGE_CACHE_SIZE;
3250 expected_index++;
3251 nr_pages++;
3252 }
3253
3254 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3255 if (!rdata) {
3256 /* best to give up if we're out of mem */
3257 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3258 list_del(&page->lru);
3259 lru_cache_add_file(page);
3260 unlock_page(page);
3261 page_cache_release(page);
3262 }
3263 rc = -ENOMEM;
3264 break;
3265 }
3266
3267 rdata->cfile = cifsFileInfo_get(open_file);
3268 rdata->mapping = mapping;
3269 rdata->offset = offset;
3270 rdata->bytes = bytes;
3271 rdata->pid = pid;
3272 rdata->pagesz = PAGE_CACHE_SIZE;
3273 rdata->read_into_pages = cifs_readpages_read_into_pages;
3274
3275 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3276 list_del(&page->lru);
3277 rdata->pages[rdata->nr_pages++] = page;
3278 }
3279
3280 rc = cifs_retry_async_readv(rdata);
3281 if (rc != 0) {
3282 for (i = 0; i < rdata->nr_pages; i++) {
3283 page = rdata->pages[i];
3284 lru_cache_add_file(page);
3285 unlock_page(page);
3286 page_cache_release(page);
3287 }
3288 kref_put(&rdata->refcount, cifs_readdata_release);
3289 break;
3290 }
3291
3292 kref_put(&rdata->refcount, cifs_readdata_release);
3293 }
3294
3295 return rc;
3296 }
3297
3298 static int cifs_readpage_worker(struct file *file, struct page *page,
3299 loff_t *poffset)
3300 {
3301 char *read_data;
3302 int rc;
3303
3304 /* Is the page cached? */
3305 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
3306 if (rc == 0)
3307 goto read_complete;
3308
3309 page_cache_get(page);
3310 read_data = kmap(page);
3311 /* for reads over a certain size could initiate async read ahead */
3312
3313 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3314
3315 if (rc < 0)
3316 goto io_error;
3317 else
3318 cFYI(1, "Bytes read %d", rc);
3319
3320 file->f_path.dentry->d_inode->i_atime =
3321 current_fs_time(file->f_path.dentry->d_inode->i_sb);
3322
3323 if (PAGE_CACHE_SIZE > rc)
3324 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3325
3326 flush_dcache_page(page);
3327 SetPageUptodate(page);
3328
3329 /* send this page to the cache */
3330 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
3331
3332 rc = 0;
3333
3334 io_error:
3335 kunmap(page);
3336 page_cache_release(page);
3337
3338 read_complete:
3339 return rc;
3340 }
3341
3342 static int cifs_readpage(struct file *file, struct page *page)
3343 {
3344 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3345 int rc = -EACCES;
3346 unsigned int xid;
3347
3348 xid = get_xid();
3349
3350 if (file->private_data == NULL) {
3351 rc = -EBADF;
3352 free_xid(xid);
3353 return rc;
3354 }
3355
3356 cFYI(1, "readpage %p at offset %d 0x%x",
3357 page, (int)offset, (int)offset);
3358
3359 rc = cifs_readpage_worker(file, page, &offset);
3360
3361 unlock_page(page);
3362
3363 free_xid(xid);
3364 return rc;
3365 }
3366
3367 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3368 {
3369 struct cifsFileInfo *open_file;
3370
3371 spin_lock(&cifs_file_list_lock);
3372 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3373 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3374 spin_unlock(&cifs_file_list_lock);
3375 return 1;
3376 }
3377 }
3378 spin_unlock(&cifs_file_list_lock);
3379 return 0;
3380 }
3381
3382 /* We do not want to update the file size from server for inodes
3383 open for write - to avoid races with writepage extending
3384 the file - in the future we could consider allowing
3385 refreshing the inode only on increases in the file size
3386 but this is tricky to do without racing with writebehind
3387 page caching in the current Linux kernel design */
3388 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3389 {
3390 if (!cifsInode)
3391 return true;
3392
3393 if (is_inode_writable(cifsInode)) {
3394 /* This inode is open for write at least once */
3395 struct cifs_sb_info *cifs_sb;
3396
3397 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3398 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3399 /* since no page cache to corrupt on directio
3400 we can change size safely */
3401 return true;
3402 }
3403
3404 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3405 return true;
3406
3407 return false;
3408 } else
3409 return true;
3410 }
3411
3412 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3413 loff_t pos, unsigned len, unsigned flags,
3414 struct page **pagep, void **fsdata)
3415 {
3416 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3417 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3418 loff_t page_start = pos & PAGE_MASK;
3419 loff_t i_size;
3420 struct page *page;
3421 int rc = 0;
3422
3423 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
3424
3425 page = grab_cache_page_write_begin(mapping, index, flags);
3426 if (!page) {
3427 rc = -ENOMEM;
3428 goto out;
3429 }
3430
3431 if (PageUptodate(page))
3432 goto out;
3433
3434 /*
3435 * If we write a full page it will be up to date, no need to read from
3436 * the server. If the write is short, we'll end up doing a sync write
3437 * instead.
3438 */
3439 if (len == PAGE_CACHE_SIZE)
3440 goto out;
3441
3442 /*
3443 * optimize away the read when we have an oplock, and we're not
3444 * expecting to use any of the data we'd be reading in. That
3445 * is, when the page lies beyond the EOF, or straddles the EOF
3446 * and the write will cover all of the existing data.
3447 */
3448 if (CIFS_I(mapping->host)->clientCanCacheRead) {
3449 i_size = i_size_read(mapping->host);
3450 if (page_start >= i_size ||
3451 (offset == 0 && (pos + len) >= i_size)) {
3452 zero_user_segments(page, 0, offset,
3453 offset + len,
3454 PAGE_CACHE_SIZE);
3455 /*
3456 * PageChecked means that the parts of the page
3457 * to which we're not writing are considered up
3458 * to date. Once the data is copied to the
3459 * page, it can be set uptodate.
3460 */
3461 SetPageChecked(page);
3462 goto out;
3463 }
3464 }
3465
3466 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3467 /*
3468 * might as well read a page, it is fast enough. If we get
3469 * an error, we don't need to return it. cifs_write_end will
3470 * do a sync write instead since PG_uptodate isn't set.
3471 */
3472 cifs_readpage_worker(file, page, &page_start);
3473 } else {
3474 /* we could try using another file handle if there is one -
3475 but how would we lock it to prevent close of that handle
3476 racing with this read? In any case
3477 this will be written out by write_end so is fine */
3478 }
3479 out:
3480 *pagep = page;
3481 return rc;
3482 }
3483
3484 static int cifs_release_page(struct page *page, gfp_t gfp)
3485 {
3486 if (PagePrivate(page))
3487 return 0;
3488
3489 return cifs_fscache_release_page(page, gfp);
3490 }
3491
3492 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3493 {
3494 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3495
3496 if (offset == 0)
3497 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3498 }
3499
3500 static int cifs_launder_page(struct page *page)
3501 {
3502 int rc = 0;
3503 loff_t range_start = page_offset(page);
3504 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3505 struct writeback_control wbc = {
3506 .sync_mode = WB_SYNC_ALL,
3507 .nr_to_write = 0,
3508 .range_start = range_start,
3509 .range_end = range_end,
3510 };
3511
3512 cFYI(1, "Launder page: %p", page);
3513
3514 if (clear_page_dirty_for_io(page))
3515 rc = cifs_writepage_locked(page, &wbc);
3516
3517 cifs_fscache_invalidate_page(page, page->mapping->host);
3518 return rc;
3519 }
3520
3521 void cifs_oplock_break(struct work_struct *work)
3522 {
3523 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3524 oplock_break);
3525 struct inode *inode = cfile->dentry->d_inode;
3526 struct cifsInodeInfo *cinode = CIFS_I(inode);
3527 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3528 int rc = 0;
3529
3530 if (inode && S_ISREG(inode->i_mode)) {
3531 if (cinode->clientCanCacheRead)
3532 break_lease(inode, O_RDONLY);
3533 else
3534 break_lease(inode, O_WRONLY);
3535 rc = filemap_fdatawrite(inode->i_mapping);
3536 if (cinode->clientCanCacheRead == 0) {
3537 rc = filemap_fdatawait(inode->i_mapping);
3538 mapping_set_error(inode->i_mapping, rc);
3539 invalidate_remote_inode(inode);
3540 }
3541 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
3542 }
3543
3544 rc = cifs_push_locks(cfile);
3545 if (rc)
3546 cERROR(1, "Push locks rc = %d", rc);
3547
3548 /*
3549 * releasing stale oplock after recent reconnect of smb session using
3550 * a now incorrect file handle is not a data integrity issue but do
3551 * not bother sending an oplock release if session to server still is
3552 * disconnected since oplock already released by the server
3553 */
3554 if (!cfile->oplock_break_cancelled) {
3555 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3556 cinode);
3557 cFYI(1, "Oplock release rc = %d", rc);
3558 }
3559 }
3560
3561 const struct address_space_operations cifs_addr_ops = {
3562 .readpage = cifs_readpage,
3563 .readpages = cifs_readpages,
3564 .writepage = cifs_writepage,
3565 .writepages = cifs_writepages,
3566 .write_begin = cifs_write_begin,
3567 .write_end = cifs_write_end,
3568 .set_page_dirty = __set_page_dirty_nobuffers,
3569 .releasepage = cifs_release_page,
3570 .invalidatepage = cifs_invalidate_page,
3571 .launder_page = cifs_launder_page,
3572 };
3573
3574 /*
3575 * cifs_readpages requires the server to support a buffer large enough to
3576 * contain the header plus one complete page of data. Otherwise, we need
3577 * to leave cifs_readpages out of the address space operations.
3578 */
3579 const struct address_space_operations cifs_addr_ops_smallbuf = {
3580 .readpage = cifs_readpage,
3581 .writepage = cifs_writepage,
3582 .writepages = cifs_writepages,
3583 .write_begin = cifs_write_begin,
3584 .write_end = cifs_write_end,
3585 .set_page_dirty = __set_page_dirty_nobuffers,
3586 .releasepage = cifs_release_page,
3587 .invalidatepage = cifs_invalidate_page,
3588 .launder_page = cifs_launder_page,
3589 };
Ubuntu Jammy Linux kernel mirror