projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for_3.8-rc1' into v4l_for_linus
[deliverable/linux.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
359 xid = get_xid();
360 if (server->ops->close)
361 server->ops->close(xid, tcon, &cifs_file->fid);
362 _free_xid(xid);
363 }
364
365 cifs_del_pending_open(&open);
366
367 /*
368 * Delete any outstanding lock records. We'll lose them when the file
369 * is closed anyway.
370 */
371 down_write(&cifsi->lock_sem);
372 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
373 list_del(&li->llist);
374 cifs_del_lock_waiters(li);
375 kfree(li);
376 }
377 list_del(&cifs_file->llist->llist);
378 kfree(cifs_file->llist);
379 up_write(&cifsi->lock_sem);
380
381 cifs_put_tlink(cifs_file->tlink);
382 dput(cifs_file->dentry);
383 kfree(cifs_file);
384 }
385
386 int cifs_open(struct inode *inode, struct file *file)
387
388 {
389 int rc = -EACCES;
390 unsigned int xid;
391 __u32 oplock;
392 struct cifs_sb_info *cifs_sb;
393 struct TCP_Server_Info *server;
394 struct cifs_tcon *tcon;
395 struct tcon_link *tlink;
396 struct cifsFileInfo *cfile = NULL;
397 char *full_path = NULL;
398 bool posix_open_ok = false;
399 struct cifs_fid fid;
400 struct cifs_pending_open open;
401
402 xid = get_xid();
403
404 cifs_sb = CIFS_SB(inode->i_sb);
405 tlink = cifs_sb_tlink(cifs_sb);
406 if (IS_ERR(tlink)) {
407 free_xid(xid);
408 return PTR_ERR(tlink);
409 }
410 tcon = tlink_tcon(tlink);
411 server = tcon->ses->server;
412
413 full_path = build_path_from_dentry(file->f_path.dentry);
414 if (full_path == NULL) {
415 rc = -ENOMEM;
416 goto out;
417 }
418
419 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
420 inode, file->f_flags, full_path);
421
422 if (server->oplocks)
423 oplock = REQ_OPLOCK;
424 else
425 oplock = 0;
426
427 if (!tcon->broken_posix_open && tcon->unix_ext &&
428 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
429 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
430 /* can not refresh inode info since size could be stale */
431 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
432 cifs_sb->mnt_file_mode /* ignored */,
433 file->f_flags, &oplock, &fid.netfid, xid);
434 if (rc == 0) {
435 cFYI(1, "posix open succeeded");
436 posix_open_ok = true;
437 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
438 if (tcon->ses->serverNOS)
439 cERROR(1, "server %s of type %s returned"
440 " unexpected error on SMB posix open"
441 ", disabling posix open support."
442 " Check if server update available.",
443 tcon->ses->serverName,
444 tcon->ses->serverNOS);
445 tcon->broken_posix_open = true;
446 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
447 (rc != -EOPNOTSUPP)) /* path not found or net err */
448 goto out;
449 /*
450 * Else fallthrough to retry open the old way on network i/o
451 * or DFS errors.
452 */
453 }
454
455 if (server->ops->get_lease_key)
456 server->ops->get_lease_key(inode, &fid);
457
458 cifs_add_pending_open(&fid, tlink, &open);
459
460 if (!posix_open_ok) {
461 if (server->ops->get_lease_key)
462 server->ops->get_lease_key(inode, &fid);
463
464 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
465 file->f_flags, &oplock, &fid, xid);
466 if (rc) {
467 cifs_del_pending_open(&open);
468 goto out;
469 }
470 }
471
472 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
473 if (cfile == NULL) {
474 if (server->ops->close)
475 server->ops->close(xid, tcon, &fid);
476 cifs_del_pending_open(&open);
477 rc = -ENOMEM;
478 goto out;
479 }
480
481 cifs_fscache_set_inode_cookie(inode, file);
482
483 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
484 /*
485 * Time to set mode which we can not set earlier due to
486 * problems creating new read-only files.
487 */
488 struct cifs_unix_set_info_args args = {
489 .mode = inode->i_mode,
490 .uid = NO_CHANGE_64,
491 .gid = NO_CHANGE_64,
492 .ctime = NO_CHANGE_64,
493 .atime = NO_CHANGE_64,
494 .mtime = NO_CHANGE_64,
495 .device = 0,
496 };
497 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
498 cfile->pid);
499 }
500
501 out:
502 kfree(full_path);
503 free_xid(xid);
504 cifs_put_tlink(tlink);
505 return rc;
506 }
507
508 /*
509 * Try to reacquire byte range locks that were released when session
510 * to server was lost
511 */
512 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
513 {
514 int rc = 0;
515
516 /* BB list all locks open on this file and relock */
517
518 return rc;
519 }
520
521 static int
522 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
523 {
524 int rc = -EACCES;
525 unsigned int xid;
526 __u32 oplock;
527 struct cifs_sb_info *cifs_sb;
528 struct cifs_tcon *tcon;
529 struct TCP_Server_Info *server;
530 struct cifsInodeInfo *cinode;
531 struct inode *inode;
532 char *full_path = NULL;
533 int desired_access;
534 int disposition = FILE_OPEN;
535 int create_options = CREATE_NOT_DIR;
536 struct cifs_fid fid;
537
538 xid = get_xid();
539 mutex_lock(&cfile->fh_mutex);
540 if (!cfile->invalidHandle) {
541 mutex_unlock(&cfile->fh_mutex);
542 rc = 0;
543 free_xid(xid);
544 return rc;
545 }
546
547 inode = cfile->dentry->d_inode;
548 cifs_sb = CIFS_SB(inode->i_sb);
549 tcon = tlink_tcon(cfile->tlink);
550 server = tcon->ses->server;
551
552 /*
553 * Can not grab rename sem here because various ops, including those
554 * that already have the rename sem can end up causing writepage to get
555 * called and if the server was down that means we end up here, and we
556 * can never tell if the caller already has the rename_sem.
557 */
558 full_path = build_path_from_dentry(cfile->dentry);
559 if (full_path == NULL) {
560 rc = -ENOMEM;
561 mutex_unlock(&cfile->fh_mutex);
562 free_xid(xid);
563 return rc;
564 }
565
566 cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode, cfile->f_flags,
567 full_path);
568
569 if (tcon->ses->server->oplocks)
570 oplock = REQ_OPLOCK;
571 else
572 oplock = 0;
573
574 if (tcon->unix_ext && cap_unix(tcon->ses) &&
575 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
576 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
577 /*
578 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
579 * original open. Must mask them off for a reopen.
580 */
581 unsigned int oflags = cfile->f_flags &
582 ~(O_CREAT | O_EXCL | O_TRUNC);
583
584 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
585 cifs_sb->mnt_file_mode /* ignored */,
586 oflags, &oplock, &fid.netfid, xid);
587 if (rc == 0) {
588 cFYI(1, "posix reopen succeeded");
589 goto reopen_success;
590 }
591 /*
592 * fallthrough to retry open the old way on errors, especially
593 * in the reconnect path it is important to retry hard
594 */
595 }
596
597 desired_access = cifs_convert_flags(cfile->f_flags);
598
599 if (backup_cred(cifs_sb))
600 create_options |= CREATE_OPEN_BACKUP_INTENT;
601
602 if (server->ops->get_lease_key)
603 server->ops->get_lease_key(inode, &fid);
604
605 /*
606 * Can not refresh inode by passing in file_info buf to be returned by
607 * CIFSSMBOpen and then calling get_inode_info with returned buf since
608 * file might have write behind data that needs to be flushed and server
609 * version of file size can be stale. If we knew for sure that inode was
610 * not dirty locally we could do this.
611 */
612 rc = server->ops->open(xid, tcon, full_path, disposition,
613 desired_access, create_options, &fid, &oplock,
614 NULL, cifs_sb);
615 if (rc) {
616 mutex_unlock(&cfile->fh_mutex);
617 cFYI(1, "cifs_reopen returned 0x%x", rc);
618 cFYI(1, "oplock: %d", oplock);
619 goto reopen_error_exit;
620 }
621
622 reopen_success:
623 cfile->invalidHandle = false;
624 mutex_unlock(&cfile->fh_mutex);
625 cinode = CIFS_I(inode);
626
627 if (can_flush) {
628 rc = filemap_write_and_wait(inode->i_mapping);
629 mapping_set_error(inode->i_mapping, rc);
630
631 if (tcon->unix_ext)
632 rc = cifs_get_inode_info_unix(&inode, full_path,
633 inode->i_sb, xid);
634 else
635 rc = cifs_get_inode_info(&inode, full_path, NULL,
636 inode->i_sb, xid, NULL);
637 }
638 /*
639 * Else we are writing out data to server already and could deadlock if
640 * we tried to flush data, and since we do not know if we have data that
641 * would invalidate the current end of file on the server we can not go
642 * to the server to get the new inode info.
643 */
644
645 server->ops->set_fid(cfile, &fid, oplock);
646 cifs_relock_file(cfile);
647
648 reopen_error_exit:
649 kfree(full_path);
650 free_xid(xid);
651 return rc;
652 }
653
654 int cifs_close(struct inode *inode, struct file *file)
655 {
656 if (file->private_data != NULL) {
657 cifsFileInfo_put(file->private_data);
658 file->private_data = NULL;
659 }
660
661 /* return code from the ->release op is always ignored */
662 return 0;
663 }
664
665 int cifs_closedir(struct inode *inode, struct file *file)
666 {
667 int rc = 0;
668 unsigned int xid;
669 struct cifsFileInfo *cfile = file->private_data;
670 struct cifs_tcon *tcon;
671 struct TCP_Server_Info *server;
672 char *buf;
673
674 cFYI(1, "Closedir inode = 0x%p", inode);
675
676 if (cfile == NULL)
677 return rc;
678
679 xid = get_xid();
680 tcon = tlink_tcon(cfile->tlink);
681 server = tcon->ses->server;
682
683 cFYI(1, "Freeing private data in close dir");
684 spin_lock(&cifs_file_list_lock);
685 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
686 cfile->invalidHandle = true;
687 spin_unlock(&cifs_file_list_lock);
688 if (server->ops->close_dir)
689 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
690 else
691 rc = -ENOSYS;
692 cFYI(1, "Closing uncompleted readdir with rc %d", rc);
693 /* not much we can do if it fails anyway, ignore rc */
694 rc = 0;
695 } else
696 spin_unlock(&cifs_file_list_lock);
697
698 buf = cfile->srch_inf.ntwrk_buf_start;
699 if (buf) {
700 cFYI(1, "closedir free smb buf in srch struct");
701 cfile->srch_inf.ntwrk_buf_start = NULL;
702 if (cfile->srch_inf.smallBuf)
703 cifs_small_buf_release(buf);
704 else
705 cifs_buf_release(buf);
706 }
707
708 cifs_put_tlink(cfile->tlink);
709 kfree(file->private_data);
710 file->private_data = NULL;
711 /* BB can we lock the filestruct while this is going on? */
712 free_xid(xid);
713 return rc;
714 }
715
716 static struct cifsLockInfo *
717 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
718 {
719 struct cifsLockInfo *lock =
720 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
721 if (!lock)
722 return lock;
723 lock->offset = offset;
724 lock->length = length;
725 lock->type = type;
726 lock->pid = current->tgid;
727 INIT_LIST_HEAD(&lock->blist);
728 init_waitqueue_head(&lock->block_q);
729 return lock;
730 }
731
732 void
733 cifs_del_lock_waiters(struct cifsLockInfo *lock)
734 {
735 struct cifsLockInfo *li, *tmp;
736 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
737 list_del_init(&li->blist);
738 wake_up(&li->block_q);
739 }
740 }
741
742 static bool
743 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
744 __u64 length, __u8 type, struct cifsFileInfo *cfile,
745 struct cifsLockInfo **conf_lock, bool rw_check)
746 {
747 struct cifsLockInfo *li;
748 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
749 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
750
751 list_for_each_entry(li, &fdlocks->locks, llist) {
752 if (offset + length <= li->offset ||
753 offset >= li->offset + li->length)
754 continue;
755 if (rw_check && server->ops->compare_fids(cfile, cur_cfile) &&
756 current->tgid == li->pid)
757 continue;
758 if ((type & server->vals->shared_lock_type) &&
759 ((server->ops->compare_fids(cfile, cur_cfile) &&
760 current->tgid == li->pid) || type == li->type))
761 continue;
762 if (conf_lock)
763 *conf_lock = li;
764 return true;
765 }
766 return false;
767 }
768
769 bool
770 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
771 __u8 type, struct cifsLockInfo **conf_lock,
772 bool rw_check)
773 {
774 bool rc = false;
775 struct cifs_fid_locks *cur;
776 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
777
778 list_for_each_entry(cur, &cinode->llist, llist) {
779 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
780 cfile, conf_lock, rw_check);
781 if (rc)
782 break;
783 }
784
785 return rc;
786 }
787
788 /*
789 * Check if there is another lock that prevents us to set the lock (mandatory
790 * style). If such a lock exists, update the flock structure with its
791 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
792 * or leave it the same if we can't. Returns 0 if we don't need to request to
793 * the server or 1 otherwise.
794 */
795 static int
796 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
797 __u8 type, struct file_lock *flock)
798 {
799 int rc = 0;
800 struct cifsLockInfo *conf_lock;
801 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
802 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
803 bool exist;
804
805 down_read(&cinode->lock_sem);
806
807 exist = cifs_find_lock_conflict(cfile, offset, length, type,
808 &conf_lock, false);
809 if (exist) {
810 flock->fl_start = conf_lock->offset;
811 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
812 flock->fl_pid = conf_lock->pid;
813 if (conf_lock->type & server->vals->shared_lock_type)
814 flock->fl_type = F_RDLCK;
815 else
816 flock->fl_type = F_WRLCK;
817 } else if (!cinode->can_cache_brlcks)
818 rc = 1;
819 else
820 flock->fl_type = F_UNLCK;
821
822 up_read(&cinode->lock_sem);
823 return rc;
824 }
825
826 static void
827 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
828 {
829 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
830 down_write(&cinode->lock_sem);
831 list_add_tail(&lock->llist, &cfile->llist->locks);
832 up_write(&cinode->lock_sem);
833 }
834
835 /*
836 * Set the byte-range lock (mandatory style). Returns:
837 * 1) 0, if we set the lock and don't need to request to the server;
838 * 2) 1, if no locks prevent us but we need to request to the server;
839 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
840 */
841 static int
842 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
843 bool wait)
844 {
845 struct cifsLockInfo *conf_lock;
846 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
847 bool exist;
848 int rc = 0;
849
850 try_again:
851 exist = false;
852 down_write(&cinode->lock_sem);
853
854 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
855 lock->type, &conf_lock, false);
856 if (!exist && cinode->can_cache_brlcks) {
857 list_add_tail(&lock->llist, &cfile->llist->locks);
858 up_write(&cinode->lock_sem);
859 return rc;
860 }
861
862 if (!exist)
863 rc = 1;
864 else if (!wait)
865 rc = -EACCES;
866 else {
867 list_add_tail(&lock->blist, &conf_lock->blist);
868 up_write(&cinode->lock_sem);
869 rc = wait_event_interruptible(lock->block_q,
870 (lock->blist.prev == &lock->blist) &&
871 (lock->blist.next == &lock->blist));
872 if (!rc)
873 goto try_again;
874 down_write(&cinode->lock_sem);
875 list_del_init(&lock->blist);
876 }
877
878 up_write(&cinode->lock_sem);
879 return rc;
880 }
881
882 /*
883 * Check if there is another lock that prevents us to set the lock (posix
884 * style). If such a lock exists, update the flock structure with its
885 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
886 * or leave it the same if we can't. Returns 0 if we don't need to request to
887 * the server or 1 otherwise.
888 */
889 static int
890 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
891 {
892 int rc = 0;
893 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
894 unsigned char saved_type = flock->fl_type;
895
896 if ((flock->fl_flags & FL_POSIX) == 0)
897 return 1;
898
899 down_read(&cinode->lock_sem);
900 posix_test_lock(file, flock);
901
902 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
903 flock->fl_type = saved_type;
904 rc = 1;
905 }
906
907 up_read(&cinode->lock_sem);
908 return rc;
909 }
910
911 /*
912 * Set the byte-range lock (posix style). Returns:
913 * 1) 0, if we set the lock and don't need to request to the server;
914 * 2) 1, if we need to request to the server;
915 * 3) <0, if the error occurs while setting the lock.
916 */
917 static int
918 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
919 {
920 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
921 int rc = 1;
922
923 if ((flock->fl_flags & FL_POSIX) == 0)
924 return rc;
925
926 try_again:
927 down_write(&cinode->lock_sem);
928 if (!cinode->can_cache_brlcks) {
929 up_write(&cinode->lock_sem);
930 return rc;
931 }
932
933 rc = posix_lock_file(file, flock, NULL);
934 up_write(&cinode->lock_sem);
935 if (rc == FILE_LOCK_DEFERRED) {
936 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
937 if (!rc)
938 goto try_again;
939 locks_delete_block(flock);
940 }
941 return rc;
942 }
943
944 int
945 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
946 {
947 unsigned int xid;
948 int rc = 0, stored_rc;
949 struct cifsLockInfo *li, *tmp;
950 struct cifs_tcon *tcon;
951 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
952 unsigned int num, max_num, max_buf;
953 LOCKING_ANDX_RANGE *buf, *cur;
954 int types[] = {LOCKING_ANDX_LARGE_FILES,
955 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
956 int i;
957
958 xid = get_xid();
959 tcon = tlink_tcon(cfile->tlink);
960
961 /* we are going to update can_cache_brlcks here - need a write access */
962 down_write(&cinode->lock_sem);
963 if (!cinode->can_cache_brlcks) {
964 up_write(&cinode->lock_sem);
965 free_xid(xid);
966 return rc;
967 }
968
969 /*
970 * Accessing maxBuf is racy with cifs_reconnect - need to store value
971 * and check it for zero before using.
972 */
973 max_buf = tcon->ses->server->maxBuf;
974 if (!max_buf) {
975 up_write(&cinode->lock_sem);
976 free_xid(xid);
977 return -EINVAL;
978 }
979
980 max_num = (max_buf - sizeof(struct smb_hdr)) /
981 sizeof(LOCKING_ANDX_RANGE);
982 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
983 if (!buf) {
984 up_write(&cinode->lock_sem);
985 free_xid(xid);
986 return -ENOMEM;
987 }
988
989 for (i = 0; i < 2; i++) {
990 cur = buf;
991 num = 0;
992 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
993 if (li->type != types[i])
994 continue;
995 cur->Pid = cpu_to_le16(li->pid);
996 cur->LengthLow = cpu_to_le32((u32)li->length);
997 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
998 cur->OffsetLow = cpu_to_le32((u32)li->offset);
999 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1000 if (++num == max_num) {
1001 stored_rc = cifs_lockv(xid, tcon,
1002 cfile->fid.netfid,
1003 (__u8)li->type, 0, num,
1004 buf);
1005 if (stored_rc)
1006 rc = stored_rc;
1007 cur = buf;
1008 num = 0;
1009 } else
1010 cur++;
1011 }
1012
1013 if (num) {
1014 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1015 (__u8)types[i], 0, num, buf);
1016 if (stored_rc)
1017 rc = stored_rc;
1018 }
1019 }
1020
1021 cinode->can_cache_brlcks = false;
1022 up_write(&cinode->lock_sem);
1023
1024 kfree(buf);
1025 free_xid(xid);
1026 return rc;
1027 }
1028
1029 /* copied from fs/locks.c with a name change */
1030 #define cifs_for_each_lock(inode, lockp) \
1031 for (lockp = &inode->i_flock; *lockp != NULL; \
1032 lockp = &(*lockp)->fl_next)
1033
1034 struct lock_to_push {
1035 struct list_head llist;
1036 __u64 offset;
1037 __u64 length;
1038 __u32 pid;
1039 __u16 netfid;
1040 __u8 type;
1041 };
1042
1043 static int
1044 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1045 {
1046 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1047 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1048 struct file_lock *flock, **before;
1049 unsigned int count = 0, i = 0;
1050 int rc = 0, xid, type;
1051 struct list_head locks_to_send, *el;
1052 struct lock_to_push *lck, *tmp;
1053 __u64 length;
1054
1055 xid = get_xid();
1056
1057 /* we are going to update can_cache_brlcks here - need a write access */
1058 down_write(&cinode->lock_sem);
1059 if (!cinode->can_cache_brlcks) {
1060 up_write(&cinode->lock_sem);
1061 free_xid(xid);
1062 return rc;
1063 }
1064
1065 lock_flocks();
1066 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1067 if ((*before)->fl_flags & FL_POSIX)
1068 count++;
1069 }
1070 unlock_flocks();
1071
1072 INIT_LIST_HEAD(&locks_to_send);
1073
1074 /*
1075 * Allocating count locks is enough because no FL_POSIX locks can be
1076 * added to the list while we are holding cinode->lock_sem that
1077 * protects locking operations of this inode.
1078 */
1079 for (; i < count; i++) {
1080 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1081 if (!lck) {
1082 rc = -ENOMEM;
1083 goto err_out;
1084 }
1085 list_add_tail(&lck->llist, &locks_to_send);
1086 }
1087
1088 el = locks_to_send.next;
1089 lock_flocks();
1090 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1091 flock = *before;
1092 if ((flock->fl_flags & FL_POSIX) == 0)
1093 continue;
1094 if (el == &locks_to_send) {
1095 /*
1096 * The list ended. We don't have enough allocated
1097 * structures - something is really wrong.
1098 */
1099 cERROR(1, "Can't push all brlocks!");
1100 break;
1101 }
1102 length = 1 + flock->fl_end - flock->fl_start;
1103 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1104 type = CIFS_RDLCK;
1105 else
1106 type = CIFS_WRLCK;
1107 lck = list_entry(el, struct lock_to_push, llist);
1108 lck->pid = flock->fl_pid;
1109 lck->netfid = cfile->fid.netfid;
1110 lck->length = length;
1111 lck->type = type;
1112 lck->offset = flock->fl_start;
1113 el = el->next;
1114 }
1115 unlock_flocks();
1116
1117 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1118 int stored_rc;
1119
1120 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1121 lck->offset, lck->length, NULL,
1122 lck->type, 0);
1123 if (stored_rc)
1124 rc = stored_rc;
1125 list_del(&lck->llist);
1126 kfree(lck);
1127 }
1128
1129 out:
1130 cinode->can_cache_brlcks = false;
1131 up_write(&cinode->lock_sem);
1132
1133 free_xid(xid);
1134 return rc;
1135 err_out:
1136 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1137 list_del(&lck->llist);
1138 kfree(lck);
1139 }
1140 goto out;
1141 }
1142
1143 static int
1144 cifs_push_locks(struct cifsFileInfo *cfile)
1145 {
1146 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1147 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1148
1149 if (cap_unix(tcon->ses) &&
1150 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1151 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1152 return cifs_push_posix_locks(cfile);
1153
1154 return tcon->ses->server->ops->push_mand_locks(cfile);
1155 }
1156
1157 static void
1158 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1159 bool *wait_flag, struct TCP_Server_Info *server)
1160 {
1161 if (flock->fl_flags & FL_POSIX)
1162 cFYI(1, "Posix");
1163 if (flock->fl_flags & FL_FLOCK)
1164 cFYI(1, "Flock");
1165 if (flock->fl_flags & FL_SLEEP) {
1166 cFYI(1, "Blocking lock");
1167 *wait_flag = true;
1168 }
1169 if (flock->fl_flags & FL_ACCESS)
1170 cFYI(1, "Process suspended by mandatory locking - "
1171 "not implemented yet");
1172 if (flock->fl_flags & FL_LEASE)
1173 cFYI(1, "Lease on file - not implemented yet");
1174 if (flock->fl_flags &
1175 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1176 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1177 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1178
1179 *type = server->vals->large_lock_type;
1180 if (flock->fl_type == F_WRLCK) {
1181 cFYI(1, "F_WRLCK ");
1182 *type |= server->vals->exclusive_lock_type;
1183 *lock = 1;
1184 } else if (flock->fl_type == F_UNLCK) {
1185 cFYI(1, "F_UNLCK");
1186 *type |= server->vals->unlock_lock_type;
1187 *unlock = 1;
1188 /* Check if unlock includes more than one lock range */
1189 } else if (flock->fl_type == F_RDLCK) {
1190 cFYI(1, "F_RDLCK");
1191 *type |= server->vals->shared_lock_type;
1192 *lock = 1;
1193 } else if (flock->fl_type == F_EXLCK) {
1194 cFYI(1, "F_EXLCK");
1195 *type |= server->vals->exclusive_lock_type;
1196 *lock = 1;
1197 } else if (flock->fl_type == F_SHLCK) {
1198 cFYI(1, "F_SHLCK");
1199 *type |= server->vals->shared_lock_type;
1200 *lock = 1;
1201 } else
1202 cFYI(1, "Unknown type of lock");
1203 }
1204
1205 static int
1206 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1207 bool wait_flag, bool posix_lck, unsigned int xid)
1208 {
1209 int rc = 0;
1210 __u64 length = 1 + flock->fl_end - flock->fl_start;
1211 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1212 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1213 struct TCP_Server_Info *server = tcon->ses->server;
1214 __u16 netfid = cfile->fid.netfid;
1215
1216 if (posix_lck) {
1217 int posix_lock_type;
1218
1219 rc = cifs_posix_lock_test(file, flock);
1220 if (!rc)
1221 return rc;
1222
1223 if (type & server->vals->shared_lock_type)
1224 posix_lock_type = CIFS_RDLCK;
1225 else
1226 posix_lock_type = CIFS_WRLCK;
1227 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1228 flock->fl_start, length, flock,
1229 posix_lock_type, wait_flag);
1230 return rc;
1231 }
1232
1233 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1234 if (!rc)
1235 return rc;
1236
1237 /* BB we could chain these into one lock request BB */
1238 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1239 1, 0, false);
1240 if (rc == 0) {
1241 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1242 type, 0, 1, false);
1243 flock->fl_type = F_UNLCK;
1244 if (rc != 0)
1245 cERROR(1, "Error unlocking previously locked "
1246 "range %d during test of lock", rc);
1247 return 0;
1248 }
1249
1250 if (type & server->vals->shared_lock_type) {
1251 flock->fl_type = F_WRLCK;
1252 return 0;
1253 }
1254
1255 type &= ~server->vals->exclusive_lock_type;
1256
1257 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1258 type | server->vals->shared_lock_type,
1259 1, 0, false);
1260 if (rc == 0) {
1261 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1262 type | server->vals->shared_lock_type, 0, 1, false);
1263 flock->fl_type = F_RDLCK;
1264 if (rc != 0)
1265 cERROR(1, "Error unlocking previously locked "
1266 "range %d during test of lock", rc);
1267 } else
1268 flock->fl_type = F_WRLCK;
1269
1270 return 0;
1271 }
1272
1273 void
1274 cifs_move_llist(struct list_head *source, struct list_head *dest)
1275 {
1276 struct list_head *li, *tmp;
1277 list_for_each_safe(li, tmp, source)
1278 list_move(li, dest);
1279 }
1280
1281 void
1282 cifs_free_llist(struct list_head *llist)
1283 {
1284 struct cifsLockInfo *li, *tmp;
1285 list_for_each_entry_safe(li, tmp, llist, llist) {
1286 cifs_del_lock_waiters(li);
1287 list_del(&li->llist);
1288 kfree(li);
1289 }
1290 }
1291
1292 int
1293 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1294 unsigned int xid)
1295 {
1296 int rc = 0, stored_rc;
1297 int types[] = {LOCKING_ANDX_LARGE_FILES,
1298 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1299 unsigned int i;
1300 unsigned int max_num, num, max_buf;
1301 LOCKING_ANDX_RANGE *buf, *cur;
1302 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1303 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1304 struct cifsLockInfo *li, *tmp;
1305 __u64 length = 1 + flock->fl_end - flock->fl_start;
1306 struct list_head tmp_llist;
1307
1308 INIT_LIST_HEAD(&tmp_llist);
1309
1310 /*
1311 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1312 * and check it for zero before using.
1313 */
1314 max_buf = tcon->ses->server->maxBuf;
1315 if (!max_buf)
1316 return -EINVAL;
1317
1318 max_num = (max_buf - sizeof(struct smb_hdr)) /
1319 sizeof(LOCKING_ANDX_RANGE);
1320 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1321 if (!buf)
1322 return -ENOMEM;
1323
1324 down_write(&cinode->lock_sem);
1325 for (i = 0; i < 2; i++) {
1326 cur = buf;
1327 num = 0;
1328 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1329 if (flock->fl_start > li->offset ||
1330 (flock->fl_start + length) <
1331 (li->offset + li->length))
1332 continue;
1333 if (current->tgid != li->pid)
1334 continue;
1335 if (types[i] != li->type)
1336 continue;
1337 if (cinode->can_cache_brlcks) {
1338 /*
1339 * We can cache brlock requests - simply remove
1340 * a lock from the file's list.
1341 */
1342 list_del(&li->llist);
1343 cifs_del_lock_waiters(li);
1344 kfree(li);
1345 continue;
1346 }
1347 cur->Pid = cpu_to_le16(li->pid);
1348 cur->LengthLow = cpu_to_le32((u32)li->length);
1349 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1350 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1351 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1352 /*
1353 * We need to save a lock here to let us add it again to
1354 * the file's list if the unlock range request fails on
1355 * the server.
1356 */
1357 list_move(&li->llist, &tmp_llist);
1358 if (++num == max_num) {
1359 stored_rc = cifs_lockv(xid, tcon,
1360 cfile->fid.netfid,
1361 li->type, num, 0, buf);
1362 if (stored_rc) {
1363 /*
1364 * We failed on the unlock range
1365 * request - add all locks from the tmp
1366 * list to the head of the file's list.
1367 */
1368 cifs_move_llist(&tmp_llist,
1369 &cfile->llist->locks);
1370 rc = stored_rc;
1371 } else
1372 /*
1373 * The unlock range request succeed -
1374 * free the tmp list.
1375 */
1376 cifs_free_llist(&tmp_llist);
1377 cur = buf;
1378 num = 0;
1379 } else
1380 cur++;
1381 }
1382 if (num) {
1383 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1384 types[i], num, 0, buf);
1385 if (stored_rc) {
1386 cifs_move_llist(&tmp_llist,
1387 &cfile->llist->locks);
1388 rc = stored_rc;
1389 } else
1390 cifs_free_llist(&tmp_llist);
1391 }
1392 }
1393
1394 up_write(&cinode->lock_sem);
1395 kfree(buf);
1396 return rc;
1397 }
1398
1399 static int
1400 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1401 bool wait_flag, bool posix_lck, int lock, int unlock,
1402 unsigned int xid)
1403 {
1404 int rc = 0;
1405 __u64 length = 1 + flock->fl_end - flock->fl_start;
1406 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1407 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1408 struct TCP_Server_Info *server = tcon->ses->server;
1409
1410 if (posix_lck) {
1411 int posix_lock_type;
1412
1413 rc = cifs_posix_lock_set(file, flock);
1414 if (!rc || rc < 0)
1415 return rc;
1416
1417 if (type & server->vals->shared_lock_type)
1418 posix_lock_type = CIFS_RDLCK;
1419 else
1420 posix_lock_type = CIFS_WRLCK;
1421
1422 if (unlock == 1)
1423 posix_lock_type = CIFS_UNLCK;
1424
1425 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1426 current->tgid, flock->fl_start, length,
1427 NULL, posix_lock_type, wait_flag);
1428 goto out;
1429 }
1430
1431 if (lock) {
1432 struct cifsLockInfo *lock;
1433
1434 lock = cifs_lock_init(flock->fl_start, length, type);
1435 if (!lock)
1436 return -ENOMEM;
1437
1438 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1439 if (rc < 0)
1440 kfree(lock);
1441 if (rc <= 0)
1442 goto out;
1443
1444 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1445 type, 1, 0, wait_flag);
1446 if (rc) {
1447 kfree(lock);
1448 goto out;
1449 }
1450
1451 cifs_lock_add(cfile, lock);
1452 } else if (unlock)
1453 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1454
1455 out:
1456 if (flock->fl_flags & FL_POSIX)
1457 posix_lock_file_wait(file, flock);
1458 return rc;
1459 }
1460
1461 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1462 {
1463 int rc, xid;
1464 int lock = 0, unlock = 0;
1465 bool wait_flag = false;
1466 bool posix_lck = false;
1467 struct cifs_sb_info *cifs_sb;
1468 struct cifs_tcon *tcon;
1469 struct cifsInodeInfo *cinode;
1470 struct cifsFileInfo *cfile;
1471 __u16 netfid;
1472 __u32 type;
1473
1474 rc = -EACCES;
1475 xid = get_xid();
1476
1477 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1478 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1479 flock->fl_start, flock->fl_end);
1480
1481 cfile = (struct cifsFileInfo *)file->private_data;
1482 tcon = tlink_tcon(cfile->tlink);
1483
1484 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1485 tcon->ses->server);
1486
1487 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1488 netfid = cfile->fid.netfid;
1489 cinode = CIFS_I(file->f_path.dentry->d_inode);
1490
1491 if (cap_unix(tcon->ses) &&
1492 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1493 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1494 posix_lck = true;
1495 /*
1496 * BB add code here to normalize offset and length to account for
1497 * negative length which we can not accept over the wire.
1498 */
1499 if (IS_GETLK(cmd)) {
1500 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1501 free_xid(xid);
1502 return rc;
1503 }
1504
1505 if (!lock && !unlock) {
1506 /*
1507 * if no lock or unlock then nothing to do since we do not
1508 * know what it is
1509 */
1510 free_xid(xid);
1511 return -EOPNOTSUPP;
1512 }
1513
1514 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1515 xid);
1516 free_xid(xid);
1517 return rc;
1518 }
1519
1520 /*
1521 * update the file size (if needed) after a write. Should be called with
1522 * the inode->i_lock held
1523 */
1524 void
1525 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1526 unsigned int bytes_written)
1527 {
1528 loff_t end_of_write = offset + bytes_written;
1529
1530 if (end_of_write > cifsi->server_eof)
1531 cifsi->server_eof = end_of_write;
1532 }
1533
1534 static ssize_t
1535 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1536 size_t write_size, loff_t *offset)
1537 {
1538 int rc = 0;
1539 unsigned int bytes_written = 0;
1540 unsigned int total_written;
1541 struct cifs_sb_info *cifs_sb;
1542 struct cifs_tcon *tcon;
1543 struct TCP_Server_Info *server;
1544 unsigned int xid;
1545 struct dentry *dentry = open_file->dentry;
1546 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1547 struct cifs_io_parms io_parms;
1548
1549 cifs_sb = CIFS_SB(dentry->d_sb);
1550
1551 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1552 *offset, dentry->d_name.name);
1553
1554 tcon = tlink_tcon(open_file->tlink);
1555 server = tcon->ses->server;
1556
1557 if (!server->ops->sync_write)
1558 return -ENOSYS;
1559
1560 xid = get_xid();
1561
1562 for (total_written = 0; write_size > total_written;
1563 total_written += bytes_written) {
1564 rc = -EAGAIN;
1565 while (rc == -EAGAIN) {
1566 struct kvec iov[2];
1567 unsigned int len;
1568
1569 if (open_file->invalidHandle) {
1570 /* we could deadlock if we called
1571 filemap_fdatawait from here so tell
1572 reopen_file not to flush data to
1573 server now */
1574 rc = cifs_reopen_file(open_file, false);
1575 if (rc != 0)
1576 break;
1577 }
1578
1579 len = min((size_t)cifs_sb->wsize,
1580 write_size - total_written);
1581 /* iov[0] is reserved for smb header */
1582 iov[1].iov_base = (char *)write_data + total_written;
1583 iov[1].iov_len = len;
1584 io_parms.pid = pid;
1585 io_parms.tcon = tcon;
1586 io_parms.offset = *offset;
1587 io_parms.length = len;
1588 rc = server->ops->sync_write(xid, open_file, &io_parms,
1589 &bytes_written, iov, 1);
1590 }
1591 if (rc || (bytes_written == 0)) {
1592 if (total_written)
1593 break;
1594 else {
1595 free_xid(xid);
1596 return rc;
1597 }
1598 } else {
1599 spin_lock(&dentry->d_inode->i_lock);
1600 cifs_update_eof(cifsi, *offset, bytes_written);
1601 spin_unlock(&dentry->d_inode->i_lock);
1602 *offset += bytes_written;
1603 }
1604 }
1605
1606 cifs_stats_bytes_written(tcon, total_written);
1607
1608 if (total_written > 0) {
1609 spin_lock(&dentry->d_inode->i_lock);
1610 if (*offset > dentry->d_inode->i_size)
1611 i_size_write(dentry->d_inode, *offset);
1612 spin_unlock(&dentry->d_inode->i_lock);
1613 }
1614 mark_inode_dirty_sync(dentry->d_inode);
1615 free_xid(xid);
1616 return total_written;
1617 }
1618
1619 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1620 bool fsuid_only)
1621 {
1622 struct cifsFileInfo *open_file = NULL;
1623 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1624
1625 /* only filter by fsuid on multiuser mounts */
1626 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1627 fsuid_only = false;
1628
1629 spin_lock(&cifs_file_list_lock);
1630 /* we could simply get the first_list_entry since write-only entries
1631 are always at the end of the list but since the first entry might
1632 have a close pending, we go through the whole list */
1633 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1634 if (fsuid_only && open_file->uid != current_fsuid())
1635 continue;
1636 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1637 if (!open_file->invalidHandle) {
1638 /* found a good file */
1639 /* lock it so it will not be closed on us */
1640 cifsFileInfo_get_locked(open_file);
1641 spin_unlock(&cifs_file_list_lock);
1642 return open_file;
1643 } /* else might as well continue, and look for
1644 another, or simply have the caller reopen it
1645 again rather than trying to fix this handle */
1646 } else /* write only file */
1647 break; /* write only files are last so must be done */
1648 }
1649 spin_unlock(&cifs_file_list_lock);
1650 return NULL;
1651 }
1652
1653 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1654 bool fsuid_only)
1655 {
1656 struct cifsFileInfo *open_file, *inv_file = NULL;
1657 struct cifs_sb_info *cifs_sb;
1658 bool any_available = false;
1659 int rc;
1660 unsigned int refind = 0;
1661
1662 /* Having a null inode here (because mapping->host was set to zero by
1663 the VFS or MM) should not happen but we had reports of on oops (due to
1664 it being zero) during stress testcases so we need to check for it */
1665
1666 if (cifs_inode == NULL) {
1667 cERROR(1, "Null inode passed to cifs_writeable_file");
1668 dump_stack();
1669 return NULL;
1670 }
1671
1672 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1673
1674 /* only filter by fsuid on multiuser mounts */
1675 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1676 fsuid_only = false;
1677
1678 spin_lock(&cifs_file_list_lock);
1679 refind_writable:
1680 if (refind > MAX_REOPEN_ATT) {
1681 spin_unlock(&cifs_file_list_lock);
1682 return NULL;
1683 }
1684 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1685 if (!any_available && open_file->pid != current->tgid)
1686 continue;
1687 if (fsuid_only && open_file->uid != current_fsuid())
1688 continue;
1689 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1690 if (!open_file->invalidHandle) {
1691 /* found a good writable file */
1692 cifsFileInfo_get_locked(open_file);
1693 spin_unlock(&cifs_file_list_lock);
1694 return open_file;
1695 } else {
1696 if (!inv_file)
1697 inv_file = open_file;
1698 }
1699 }
1700 }
1701 /* couldn't find useable FH with same pid, try any available */
1702 if (!any_available) {
1703 any_available = true;
1704 goto refind_writable;
1705 }
1706
1707 if (inv_file) {
1708 any_available = false;
1709 cifsFileInfo_get_locked(inv_file);
1710 }
1711
1712 spin_unlock(&cifs_file_list_lock);
1713
1714 if (inv_file) {
1715 rc = cifs_reopen_file(inv_file, false);
1716 if (!rc)
1717 return inv_file;
1718 else {
1719 spin_lock(&cifs_file_list_lock);
1720 list_move_tail(&inv_file->flist,
1721 &cifs_inode->openFileList);
1722 spin_unlock(&cifs_file_list_lock);
1723 cifsFileInfo_put(inv_file);
1724 spin_lock(&cifs_file_list_lock);
1725 ++refind;
1726 goto refind_writable;
1727 }
1728 }
1729
1730 return NULL;
1731 }
1732
1733 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1734 {
1735 struct address_space *mapping = page->mapping;
1736 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1737 char *write_data;
1738 int rc = -EFAULT;
1739 int bytes_written = 0;
1740 struct inode *inode;
1741 struct cifsFileInfo *open_file;
1742
1743 if (!mapping || !mapping->host)
1744 return -EFAULT;
1745
1746 inode = page->mapping->host;
1747
1748 offset += (loff_t)from;
1749 write_data = kmap(page);
1750 write_data += from;
1751
1752 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1753 kunmap(page);
1754 return -EIO;
1755 }
1756
1757 /* racing with truncate? */
1758 if (offset > mapping->host->i_size) {
1759 kunmap(page);
1760 return 0; /* don't care */
1761 }
1762
1763 /* check to make sure that we are not extending the file */
1764 if (mapping->host->i_size - offset < (loff_t)to)
1765 to = (unsigned)(mapping->host->i_size - offset);
1766
1767 open_file = find_writable_file(CIFS_I(mapping->host), false);
1768 if (open_file) {
1769 bytes_written = cifs_write(open_file, open_file->pid,
1770 write_data, to - from, &offset);
1771 cifsFileInfo_put(open_file);
1772 /* Does mm or vfs already set times? */
1773 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1774 if ((bytes_written > 0) && (offset))
1775 rc = 0;
1776 else if (bytes_written < 0)
1777 rc = bytes_written;
1778 } else {
1779 cFYI(1, "No writeable filehandles for inode");
1780 rc = -EIO;
1781 }
1782
1783 kunmap(page);
1784 return rc;
1785 }
1786
1787 static int cifs_writepages(struct address_space *mapping,
1788 struct writeback_control *wbc)
1789 {
1790 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1791 bool done = false, scanned = false, range_whole = false;
1792 pgoff_t end, index;
1793 struct cifs_writedata *wdata;
1794 struct TCP_Server_Info *server;
1795 struct page *page;
1796 int rc = 0;
1797
1798 /*
1799 * If wsize is smaller than the page cache size, default to writing
1800 * one page at a time via cifs_writepage
1801 */
1802 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1803 return generic_writepages(mapping, wbc);
1804
1805 if (wbc->range_cyclic) {
1806 index = mapping->writeback_index; /* Start from prev offset */
1807 end = -1;
1808 } else {
1809 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1810 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1811 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1812 range_whole = true;
1813 scanned = true;
1814 }
1815 retry:
1816 while (!done && index <= end) {
1817 unsigned int i, nr_pages, found_pages;
1818 pgoff_t next = 0, tofind;
1819 struct page **pages;
1820
1821 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1822 end - index) + 1;
1823
1824 wdata = cifs_writedata_alloc((unsigned int)tofind,
1825 cifs_writev_complete);
1826 if (!wdata) {
1827 rc = -ENOMEM;
1828 break;
1829 }
1830
1831 /*
1832 * find_get_pages_tag seems to return a max of 256 on each
1833 * iteration, so we must call it several times in order to
1834 * fill the array or the wsize is effectively limited to
1835 * 256 * PAGE_CACHE_SIZE.
1836 */
1837 found_pages = 0;
1838 pages = wdata->pages;
1839 do {
1840 nr_pages = find_get_pages_tag(mapping, &index,
1841 PAGECACHE_TAG_DIRTY,
1842 tofind, pages);
1843 found_pages += nr_pages;
1844 tofind -= nr_pages;
1845 pages += nr_pages;
1846 } while (nr_pages && tofind && index <= end);
1847
1848 if (found_pages == 0) {
1849 kref_put(&wdata->refcount, cifs_writedata_release);
1850 break;
1851 }
1852
1853 nr_pages = 0;
1854 for (i = 0; i < found_pages; i++) {
1855 page = wdata->pages[i];
1856 /*
1857 * At this point we hold neither mapping->tree_lock nor
1858 * lock on the page itself: the page may be truncated or
1859 * invalidated (changing page->mapping to NULL), or even
1860 * swizzled back from swapper_space to tmpfs file
1861 * mapping
1862 */
1863
1864 if (nr_pages == 0)
1865 lock_page(page);
1866 else if (!trylock_page(page))
1867 break;
1868
1869 if (unlikely(page->mapping != mapping)) {
1870 unlock_page(page);
1871 break;
1872 }
1873
1874 if (!wbc->range_cyclic && page->index > end) {
1875 done = true;
1876 unlock_page(page);
1877 break;
1878 }
1879
1880 if (next && (page->index != next)) {
1881 /* Not next consecutive page */
1882 unlock_page(page);
1883 break;
1884 }
1885
1886 if (wbc->sync_mode != WB_SYNC_NONE)
1887 wait_on_page_writeback(page);
1888
1889 if (PageWriteback(page) ||
1890 !clear_page_dirty_for_io(page)) {
1891 unlock_page(page);
1892 break;
1893 }
1894
1895 /*
1896 * This actually clears the dirty bit in the radix tree.
1897 * See cifs_writepage() for more commentary.
1898 */
1899 set_page_writeback(page);
1900
1901 if (page_offset(page) >= i_size_read(mapping->host)) {
1902 done = true;
1903 unlock_page(page);
1904 end_page_writeback(page);
1905 break;
1906 }
1907
1908 wdata->pages[i] = page;
1909 next = page->index + 1;
1910 ++nr_pages;
1911 }
1912
1913 /* reset index to refind any pages skipped */
1914 if (nr_pages == 0)
1915 index = wdata->pages[0]->index + 1;
1916
1917 /* put any pages we aren't going to use */
1918 for (i = nr_pages; i < found_pages; i++) {
1919 page_cache_release(wdata->pages[i]);
1920 wdata->pages[i] = NULL;
1921 }
1922
1923 /* nothing to write? */
1924 if (nr_pages == 0) {
1925 kref_put(&wdata->refcount, cifs_writedata_release);
1926 continue;
1927 }
1928
1929 wdata->sync_mode = wbc->sync_mode;
1930 wdata->nr_pages = nr_pages;
1931 wdata->offset = page_offset(wdata->pages[0]);
1932 wdata->pagesz = PAGE_CACHE_SIZE;
1933 wdata->tailsz =
1934 min(i_size_read(mapping->host) -
1935 page_offset(wdata->pages[nr_pages - 1]),
1936 (loff_t)PAGE_CACHE_SIZE);
1937 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
1938 wdata->tailsz;
1939
1940 do {
1941 if (wdata->cfile != NULL)
1942 cifsFileInfo_put(wdata->cfile);
1943 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1944 false);
1945 if (!wdata->cfile) {
1946 cERROR(1, "No writable handles for inode");
1947 rc = -EBADF;
1948 break;
1949 }
1950 wdata->pid = wdata->cfile->pid;
1951 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1952 rc = server->ops->async_writev(wdata);
1953 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1954
1955 for (i = 0; i < nr_pages; ++i)
1956 unlock_page(wdata->pages[i]);
1957
1958 /* send failure -- clean up the mess */
1959 if (rc != 0) {
1960 for (i = 0; i < nr_pages; ++i) {
1961 if (rc == -EAGAIN)
1962 redirty_page_for_writepage(wbc,
1963 wdata->pages[i]);
1964 else
1965 SetPageError(wdata->pages[i]);
1966 end_page_writeback(wdata->pages[i]);
1967 page_cache_release(wdata->pages[i]);
1968 }
1969 if (rc != -EAGAIN)
1970 mapping_set_error(mapping, rc);
1971 }
1972 kref_put(&wdata->refcount, cifs_writedata_release);
1973
1974 wbc->nr_to_write -= nr_pages;
1975 if (wbc->nr_to_write <= 0)
1976 done = true;
1977
1978 index = next;
1979 }
1980
1981 if (!scanned && !done) {
1982 /*
1983 * We hit the last page and there is more work to be done: wrap
1984 * back to the start of the file
1985 */
1986 scanned = true;
1987 index = 0;
1988 goto retry;
1989 }
1990
1991 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1992 mapping->writeback_index = index;
1993
1994 return rc;
1995 }
1996
1997 static int
1998 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1999 {
2000 int rc;
2001 unsigned int xid;
2002
2003 xid = get_xid();
2004 /* BB add check for wbc flags */
2005 page_cache_get(page);
2006 if (!PageUptodate(page))
2007 cFYI(1, "ppw - page not up to date");
2008
2009 /*
2010 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2011 *
2012 * A writepage() implementation always needs to do either this,
2013 * or re-dirty the page with "redirty_page_for_writepage()" in
2014 * the case of a failure.
2015 *
2016 * Just unlocking the page will cause the radix tree tag-bits
2017 * to fail to update with the state of the page correctly.
2018 */
2019 set_page_writeback(page);
2020 retry_write:
2021 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2022 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2023 goto retry_write;
2024 else if (rc == -EAGAIN)
2025 redirty_page_for_writepage(wbc, page);
2026 else if (rc != 0)
2027 SetPageError(page);
2028 else
2029 SetPageUptodate(page);
2030 end_page_writeback(page);
2031 page_cache_release(page);
2032 free_xid(xid);
2033 return rc;
2034 }
2035
2036 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2037 {
2038 int rc = cifs_writepage_locked(page, wbc);
2039 unlock_page(page);
2040 return rc;
2041 }
2042
2043 static int cifs_write_end(struct file *file, struct address_space *mapping,
2044 loff_t pos, unsigned len, unsigned copied,
2045 struct page *page, void *fsdata)
2046 {
2047 int rc;
2048 struct inode *inode = mapping->host;
2049 struct cifsFileInfo *cfile = file->private_data;
2050 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2051 __u32 pid;
2052
2053 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2054 pid = cfile->pid;
2055 else
2056 pid = current->tgid;
2057
2058 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2059 page, pos, copied);
2060
2061 if (PageChecked(page)) {
2062 if (copied == len)
2063 SetPageUptodate(page);
2064 ClearPageChecked(page);
2065 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2066 SetPageUptodate(page);
2067
2068 if (!PageUptodate(page)) {
2069 char *page_data;
2070 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2071 unsigned int xid;
2072
2073 xid = get_xid();
2074 /* this is probably better than directly calling
2075 partialpage_write since in this function the file handle is
2076 known which we might as well leverage */
2077 /* BB check if anything else missing out of ppw
2078 such as updating last write time */
2079 page_data = kmap(page);
2080 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2081 /* if (rc < 0) should we set writebehind rc? */
2082 kunmap(page);
2083
2084 free_xid(xid);
2085 } else {
2086 rc = copied;
2087 pos += copied;
2088 set_page_dirty(page);
2089 }
2090
2091 if (rc > 0) {
2092 spin_lock(&inode->i_lock);
2093 if (pos > inode->i_size)
2094 i_size_write(inode, pos);
2095 spin_unlock(&inode->i_lock);
2096 }
2097
2098 unlock_page(page);
2099 page_cache_release(page);
2100
2101 return rc;
2102 }
2103
2104 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2105 int datasync)
2106 {
2107 unsigned int xid;
2108 int rc = 0;
2109 struct cifs_tcon *tcon;
2110 struct TCP_Server_Info *server;
2111 struct cifsFileInfo *smbfile = file->private_data;
2112 struct inode *inode = file->f_path.dentry->d_inode;
2113 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2114
2115 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2116 if (rc)
2117 return rc;
2118 mutex_lock(&inode->i_mutex);
2119
2120 xid = get_xid();
2121
2122 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2123 file->f_path.dentry->d_name.name, datasync);
2124
2125 if (!CIFS_I(inode)->clientCanCacheRead) {
2126 rc = cifs_invalidate_mapping(inode);
2127 if (rc) {
2128 cFYI(1, "rc: %d during invalidate phase", rc);
2129 rc = 0; /* don't care about it in fsync */
2130 }
2131 }
2132
2133 tcon = tlink_tcon(smbfile->tlink);
2134 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2135 server = tcon->ses->server;
2136 if (server->ops->flush)
2137 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2138 else
2139 rc = -ENOSYS;
2140 }
2141
2142 free_xid(xid);
2143 mutex_unlock(&inode->i_mutex);
2144 return rc;
2145 }
2146
2147 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2148 {
2149 unsigned int xid;
2150 int rc = 0;
2151 struct cifs_tcon *tcon;
2152 struct TCP_Server_Info *server;
2153 struct cifsFileInfo *smbfile = file->private_data;
2154 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2155 struct inode *inode = file->f_mapping->host;
2156
2157 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2158 if (rc)
2159 return rc;
2160 mutex_lock(&inode->i_mutex);
2161
2162 xid = get_xid();
2163
2164 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2165 file->f_path.dentry->d_name.name, datasync);
2166
2167 tcon = tlink_tcon(smbfile->tlink);
2168 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2169 server = tcon->ses->server;
2170 if (server->ops->flush)
2171 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2172 else
2173 rc = -ENOSYS;
2174 }
2175
2176 free_xid(xid);
2177 mutex_unlock(&inode->i_mutex);
2178 return rc;
2179 }
2180
2181 /*
2182 * As file closes, flush all cached write data for this inode checking
2183 * for write behind errors.
2184 */
2185 int cifs_flush(struct file *file, fl_owner_t id)
2186 {
2187 struct inode *inode = file->f_path.dentry->d_inode;
2188 int rc = 0;
2189
2190 if (file->f_mode & FMODE_WRITE)
2191 rc = filemap_write_and_wait(inode->i_mapping);
2192
2193 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2194
2195 return rc;
2196 }
2197
2198 static int
2199 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2200 {
2201 int rc = 0;
2202 unsigned long i;
2203
2204 for (i = 0; i < num_pages; i++) {
2205 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2206 if (!pages[i]) {
2207 /*
2208 * save number of pages we have already allocated and
2209 * return with ENOMEM error
2210 */
2211 num_pages = i;
2212 rc = -ENOMEM;
2213 break;
2214 }
2215 }
2216
2217 if (rc) {
2218 for (i = 0; i < num_pages; i++)
2219 put_page(pages[i]);
2220 }
2221 return rc;
2222 }
2223
2224 static inline
2225 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2226 {
2227 size_t num_pages;
2228 size_t clen;
2229
2230 clen = min_t(const size_t, len, wsize);
2231 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2232
2233 if (cur_len)
2234 *cur_len = clen;
2235
2236 return num_pages;
2237 }
2238
2239 static void
2240 cifs_uncached_writev_complete(struct work_struct *work)
2241 {
2242 int i;
2243 struct cifs_writedata *wdata = container_of(work,
2244 struct cifs_writedata, work);
2245 struct inode *inode = wdata->cfile->dentry->d_inode;
2246 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2247
2248 spin_lock(&inode->i_lock);
2249 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2250 if (cifsi->server_eof > inode->i_size)
2251 i_size_write(inode, cifsi->server_eof);
2252 spin_unlock(&inode->i_lock);
2253
2254 complete(&wdata->done);
2255
2256 if (wdata->result != -EAGAIN) {
2257 for (i = 0; i < wdata->nr_pages; i++)
2258 put_page(wdata->pages[i]);
2259 }
2260
2261 kref_put(&wdata->refcount, cifs_writedata_release);
2262 }
2263
2264 /* attempt to send write to server, retry on any -EAGAIN errors */
2265 static int
2266 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2267 {
2268 int rc;
2269 struct TCP_Server_Info *server;
2270
2271 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2272
2273 do {
2274 if (wdata->cfile->invalidHandle) {
2275 rc = cifs_reopen_file(wdata->cfile, false);
2276 if (rc != 0)
2277 continue;
2278 }
2279 rc = server->ops->async_writev(wdata);
2280 } while (rc == -EAGAIN);
2281
2282 return rc;
2283 }
2284
2285 static ssize_t
2286 cifs_iovec_write(struct file *file, const struct iovec *iov,
2287 unsigned long nr_segs, loff_t *poffset)
2288 {
2289 unsigned long nr_pages, i;
2290 size_t copied, len, cur_len;
2291 ssize_t total_written = 0;
2292 loff_t offset;
2293 struct iov_iter it;
2294 struct cifsFileInfo *open_file;
2295 struct cifs_tcon *tcon;
2296 struct cifs_sb_info *cifs_sb;
2297 struct cifs_writedata *wdata, *tmp;
2298 struct list_head wdata_list;
2299 int rc;
2300 pid_t pid;
2301
2302 len = iov_length(iov, nr_segs);
2303 if (!len)
2304 return 0;
2305
2306 rc = generic_write_checks(file, poffset, &len, 0);
2307 if (rc)
2308 return rc;
2309
2310 INIT_LIST_HEAD(&wdata_list);
2311 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2312 open_file = file->private_data;
2313 tcon = tlink_tcon(open_file->tlink);
2314
2315 if (!tcon->ses->server->ops->async_writev)
2316 return -ENOSYS;
2317
2318 offset = *poffset;
2319
2320 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2321 pid = open_file->pid;
2322 else
2323 pid = current->tgid;
2324
2325 iov_iter_init(&it, iov, nr_segs, len, 0);
2326 do {
2327 size_t save_len;
2328
2329 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2330 wdata = cifs_writedata_alloc(nr_pages,
2331 cifs_uncached_writev_complete);
2332 if (!wdata) {
2333 rc = -ENOMEM;
2334 break;
2335 }
2336
2337 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2338 if (rc) {
2339 kfree(wdata);
2340 break;
2341 }
2342
2343 save_len = cur_len;
2344 for (i = 0; i < nr_pages; i++) {
2345 copied = min_t(const size_t, cur_len, PAGE_SIZE);
2346 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2347 0, copied);
2348 cur_len -= copied;
2349 iov_iter_advance(&it, copied);
2350 }
2351 cur_len = save_len - cur_len;
2352
2353 wdata->sync_mode = WB_SYNC_ALL;
2354 wdata->nr_pages = nr_pages;
2355 wdata->offset = (__u64)offset;
2356 wdata->cfile = cifsFileInfo_get(open_file);
2357 wdata->pid = pid;
2358 wdata->bytes = cur_len;
2359 wdata->pagesz = PAGE_SIZE;
2360 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2361 rc = cifs_uncached_retry_writev(wdata);
2362 if (rc) {
2363 kref_put(&wdata->refcount, cifs_writedata_release);
2364 break;
2365 }
2366
2367 list_add_tail(&wdata->list, &wdata_list);
2368 offset += cur_len;
2369 len -= cur_len;
2370 } while (len > 0);
2371
2372 /*
2373 * If at least one write was successfully sent, then discard any rc
2374 * value from the later writes. If the other write succeeds, then
2375 * we'll end up returning whatever was written. If it fails, then
2376 * we'll get a new rc value from that.
2377 */
2378 if (!list_empty(&wdata_list))
2379 rc = 0;
2380
2381 /*
2382 * Wait for and collect replies for any successful sends in order of
2383 * increasing offset. Once an error is hit or we get a fatal signal
2384 * while waiting, then return without waiting for any more replies.
2385 */
2386 restart_loop:
2387 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2388 if (!rc) {
2389 /* FIXME: freezable too? */
2390 rc = wait_for_completion_killable(&wdata->done);
2391 if (rc)
2392 rc = -EINTR;
2393 else if (wdata->result)
2394 rc = wdata->result;
2395 else
2396 total_written += wdata->bytes;
2397
2398 /* resend call if it's a retryable error */
2399 if (rc == -EAGAIN) {
2400 rc = cifs_uncached_retry_writev(wdata);
2401 goto restart_loop;
2402 }
2403 }
2404 list_del_init(&wdata->list);
2405 kref_put(&wdata->refcount, cifs_writedata_release);
2406 }
2407
2408 if (total_written > 0)
2409 *poffset += total_written;
2410
2411 cifs_stats_bytes_written(tcon, total_written);
2412 return total_written ? total_written : (ssize_t)rc;
2413 }
2414
2415 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2416 unsigned long nr_segs, loff_t pos)
2417 {
2418 ssize_t written;
2419 struct inode *inode;
2420
2421 inode = iocb->ki_filp->f_path.dentry->d_inode;
2422
2423 /*
2424 * BB - optimize the way when signing is disabled. We can drop this
2425 * extra memory-to-memory copying and use iovec buffers for constructing
2426 * write request.
2427 */
2428
2429 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2430 if (written > 0) {
2431 CIFS_I(inode)->invalid_mapping = true;
2432 iocb->ki_pos = pos;
2433 }
2434
2435 return written;
2436 }
2437
2438 static ssize_t
2439 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2440 unsigned long nr_segs, loff_t pos)
2441 {
2442 struct file *file = iocb->ki_filp;
2443 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2444 struct inode *inode = file->f_mapping->host;
2445 struct cifsInodeInfo *cinode = CIFS_I(inode);
2446 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2447 ssize_t rc = -EACCES;
2448
2449 BUG_ON(iocb->ki_pos != pos);
2450
2451 sb_start_write(inode->i_sb);
2452
2453 /*
2454 * We need to hold the sem to be sure nobody modifies lock list
2455 * with a brlock that prevents writing.
2456 */
2457 down_read(&cinode->lock_sem);
2458 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2459 server->vals->exclusive_lock_type, NULL,
2460 true)) {
2461 mutex_lock(&inode->i_mutex);
2462 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2463 &iocb->ki_pos);
2464 mutex_unlock(&inode->i_mutex);
2465 }
2466
2467 if (rc > 0 || rc == -EIOCBQUEUED) {
2468 ssize_t err;
2469
2470 err = generic_write_sync(file, pos, rc);
2471 if (err < 0 && rc > 0)
2472 rc = err;
2473 }
2474
2475 up_read(&cinode->lock_sem);
2476 sb_end_write(inode->i_sb);
2477 return rc;
2478 }
2479
2480 ssize_t
2481 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2482 unsigned long nr_segs, loff_t pos)
2483 {
2484 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2485 struct cifsInodeInfo *cinode = CIFS_I(inode);
2486 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2487 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2488 iocb->ki_filp->private_data;
2489 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2490
2491 #ifdef CONFIG_CIFS_SMB2
2492 /*
2493 * If we have an oplock for read and want to write a data to the file
2494 * we need to store it in the page cache and then push it to the server
2495 * to be sure the next read will get a valid data.
2496 */
2497 if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead) {
2498 ssize_t written;
2499 int rc;
2500
2501 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
2502 rc = filemap_fdatawrite(inode->i_mapping);
2503 if (rc)
2504 return (ssize_t)rc;
2505
2506 return written;
2507 }
2508 #endif
2509
2510 /*
2511 * For non-oplocked files in strict cache mode we need to write the data
2512 * to the server exactly from the pos to pos+len-1 rather than flush all
2513 * affected pages because it may cause a error with mandatory locks on
2514 * these pages but not on the region from pos to ppos+len-1.
2515 */
2516
2517 if (!cinode->clientCanCacheAll)
2518 return cifs_user_writev(iocb, iov, nr_segs, pos);
2519
2520 if (cap_unix(tcon->ses) &&
2521 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2522 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2523 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2524
2525 return cifs_writev(iocb, iov, nr_segs, pos);
2526 }
2527
2528 static struct cifs_readdata *
2529 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2530 {
2531 struct cifs_readdata *rdata;
2532
2533 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2534 GFP_KERNEL);
2535 if (rdata != NULL) {
2536 kref_init(&rdata->refcount);
2537 INIT_LIST_HEAD(&rdata->list);
2538 init_completion(&rdata->done);
2539 INIT_WORK(&rdata->work, complete);
2540 }
2541
2542 return rdata;
2543 }
2544
2545 void
2546 cifs_readdata_release(struct kref *refcount)
2547 {
2548 struct cifs_readdata *rdata = container_of(refcount,
2549 struct cifs_readdata, refcount);
2550
2551 if (rdata->cfile)
2552 cifsFileInfo_put(rdata->cfile);
2553
2554 kfree(rdata);
2555 }
2556
2557 static int
2558 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2559 {
2560 int rc = 0;
2561 struct page *page;
2562 unsigned int i;
2563
2564 for (i = 0; i < nr_pages; i++) {
2565 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2566 if (!page) {
2567 rc = -ENOMEM;
2568 break;
2569 }
2570 rdata->pages[i] = page;
2571 }
2572
2573 if (rc) {
2574 for (i = 0; i < nr_pages; i++) {
2575 put_page(rdata->pages[i]);
2576 rdata->pages[i] = NULL;
2577 }
2578 }
2579 return rc;
2580 }
2581
2582 static void
2583 cifs_uncached_readdata_release(struct kref *refcount)
2584 {
2585 struct cifs_readdata *rdata = container_of(refcount,
2586 struct cifs_readdata, refcount);
2587 unsigned int i;
2588
2589 for (i = 0; i < rdata->nr_pages; i++) {
2590 put_page(rdata->pages[i]);
2591 rdata->pages[i] = NULL;
2592 }
2593 cifs_readdata_release(refcount);
2594 }
2595
2596 static int
2597 cifs_retry_async_readv(struct cifs_readdata *rdata)
2598 {
2599 int rc;
2600 struct TCP_Server_Info *server;
2601
2602 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2603
2604 do {
2605 if (rdata->cfile->invalidHandle) {
2606 rc = cifs_reopen_file(rdata->cfile, true);
2607 if (rc != 0)
2608 continue;
2609 }
2610 rc = server->ops->async_readv(rdata);
2611 } while (rc == -EAGAIN);
2612
2613 return rc;
2614 }
2615
2616 /**
2617 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2618 * @rdata: the readdata response with list of pages holding data
2619 * @iov: vector in which we should copy the data
2620 * @nr_segs: number of segments in vector
2621 * @offset: offset into file of the first iovec
2622 * @copied: used to return the amount of data copied to the iov
2623 *
2624 * This function copies data from a list of pages in a readdata response into
2625 * an array of iovecs. It will first calculate where the data should go
2626 * based on the info in the readdata and then copy the data into that spot.
2627 */
2628 static ssize_t
2629 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2630 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2631 {
2632 int rc = 0;
2633 struct iov_iter ii;
2634 size_t pos = rdata->offset - offset;
2635 ssize_t remaining = rdata->bytes;
2636 unsigned char *pdata;
2637 unsigned int i;
2638
2639 /* set up iov_iter and advance to the correct offset */
2640 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2641 iov_iter_advance(&ii, pos);
2642
2643 *copied = 0;
2644 for (i = 0; i < rdata->nr_pages; i++) {
2645 ssize_t copy;
2646 struct page *page = rdata->pages[i];
2647
2648 /* copy a whole page or whatever's left */
2649 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2650
2651 /* ...but limit it to whatever space is left in the iov */
2652 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2653
2654 /* go while there's data to be copied and no errors */
2655 if (copy && !rc) {
2656 pdata = kmap(page);
2657 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2658 (int)copy);
2659 kunmap(page);
2660 if (!rc) {
2661 *copied += copy;
2662 remaining -= copy;
2663 iov_iter_advance(&ii, copy);
2664 }
2665 }
2666 }
2667
2668 return rc;
2669 }
2670
2671 static void
2672 cifs_uncached_readv_complete(struct work_struct *work)
2673 {
2674 struct cifs_readdata *rdata = container_of(work,
2675 struct cifs_readdata, work);
2676
2677 complete(&rdata->done);
2678 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2679 }
2680
2681 static int
2682 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2683 struct cifs_readdata *rdata, unsigned int len)
2684 {
2685 int total_read = 0, result = 0;
2686 unsigned int i;
2687 unsigned int nr_pages = rdata->nr_pages;
2688 struct kvec iov;
2689
2690 rdata->tailsz = PAGE_SIZE;
2691 for (i = 0; i < nr_pages; i++) {
2692 struct page *page = rdata->pages[i];
2693
2694 if (len >= PAGE_SIZE) {
2695 /* enough data to fill the page */
2696 iov.iov_base = kmap(page);
2697 iov.iov_len = PAGE_SIZE;
2698 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2699 i, iov.iov_base, iov.iov_len);
2700 len -= PAGE_SIZE;
2701 } else if (len > 0) {
2702 /* enough for partial page, fill and zero the rest */
2703 iov.iov_base = kmap(page);
2704 iov.iov_len = len;
2705 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2706 i, iov.iov_base, iov.iov_len);
2707 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2708 rdata->tailsz = len;
2709 len = 0;
2710 } else {
2711 /* no need to hold page hostage */
2712 rdata->pages[i] = NULL;
2713 rdata->nr_pages--;
2714 put_page(page);
2715 continue;
2716 }
2717
2718 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2719 kunmap(page);
2720 if (result < 0)
2721 break;
2722
2723 total_read += result;
2724 }
2725
2726 return total_read > 0 ? total_read : result;
2727 }
2728
2729 static ssize_t
2730 cifs_iovec_read(struct file *file, const struct iovec *iov,
2731 unsigned long nr_segs, loff_t *poffset)
2732 {
2733 ssize_t rc;
2734 size_t len, cur_len;
2735 ssize_t total_read = 0;
2736 loff_t offset = *poffset;
2737 unsigned int npages;
2738 struct cifs_sb_info *cifs_sb;
2739 struct cifs_tcon *tcon;
2740 struct cifsFileInfo *open_file;
2741 struct cifs_readdata *rdata, *tmp;
2742 struct list_head rdata_list;
2743 pid_t pid;
2744
2745 if (!nr_segs)
2746 return 0;
2747
2748 len = iov_length(iov, nr_segs);
2749 if (!len)
2750 return 0;
2751
2752 INIT_LIST_HEAD(&rdata_list);
2753 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2754 open_file = file->private_data;
2755 tcon = tlink_tcon(open_file->tlink);
2756
2757 if (!tcon->ses->server->ops->async_readv)
2758 return -ENOSYS;
2759
2760 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2761 pid = open_file->pid;
2762 else
2763 pid = current->tgid;
2764
2765 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2766 cFYI(1, "attempting read on write only file instance");
2767
2768 do {
2769 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2770 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2771
2772 /* allocate a readdata struct */
2773 rdata = cifs_readdata_alloc(npages,
2774 cifs_uncached_readv_complete);
2775 if (!rdata) {
2776 rc = -ENOMEM;
2777 goto error;
2778 }
2779
2780 rc = cifs_read_allocate_pages(rdata, npages);
2781 if (rc)
2782 goto error;
2783
2784 rdata->cfile = cifsFileInfo_get(open_file);
2785 rdata->nr_pages = npages;
2786 rdata->offset = offset;
2787 rdata->bytes = cur_len;
2788 rdata->pid = pid;
2789 rdata->pagesz = PAGE_SIZE;
2790 rdata->read_into_pages = cifs_uncached_read_into_pages;
2791
2792 rc = cifs_retry_async_readv(rdata);
2793 error:
2794 if (rc) {
2795 kref_put(&rdata->refcount,
2796 cifs_uncached_readdata_release);
2797 break;
2798 }
2799
2800 list_add_tail(&rdata->list, &rdata_list);
2801 offset += cur_len;
2802 len -= cur_len;
2803 } while (len > 0);
2804
2805 /* if at least one read request send succeeded, then reset rc */
2806 if (!list_empty(&rdata_list))
2807 rc = 0;
2808
2809 /* the loop below should proceed in the order of increasing offsets */
2810 restart_loop:
2811 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2812 if (!rc) {
2813 ssize_t copied;
2814
2815 /* FIXME: freezable sleep too? */
2816 rc = wait_for_completion_killable(&rdata->done);
2817 if (rc)
2818 rc = -EINTR;
2819 else if (rdata->result)
2820 rc = rdata->result;
2821 else {
2822 rc = cifs_readdata_to_iov(rdata, iov,
2823 nr_segs, *poffset,
2824 &copied);
2825 total_read += copied;
2826 }
2827
2828 /* resend call if it's a retryable error */
2829 if (rc == -EAGAIN) {
2830 rc = cifs_retry_async_readv(rdata);
2831 goto restart_loop;
2832 }
2833 }
2834 list_del_init(&rdata->list);
2835 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2836 }
2837
2838 cifs_stats_bytes_read(tcon, total_read);
2839 *poffset += total_read;
2840
2841 /* mask nodata case */
2842 if (rc == -ENODATA)
2843 rc = 0;
2844
2845 return total_read ? total_read : rc;
2846 }
2847
2848 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2849 unsigned long nr_segs, loff_t pos)
2850 {
2851 ssize_t read;
2852
2853 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2854 if (read > 0)
2855 iocb->ki_pos = pos;
2856
2857 return read;
2858 }
2859
2860 ssize_t
2861 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2862 unsigned long nr_segs, loff_t pos)
2863 {
2864 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2865 struct cifsInodeInfo *cinode = CIFS_I(inode);
2866 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2867 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2868 iocb->ki_filp->private_data;
2869 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2870 int rc = -EACCES;
2871
2872 /*
2873 * In strict cache mode we need to read from the server all the time
2874 * if we don't have level II oplock because the server can delay mtime
2875 * change - so we can't make a decision about inode invalidating.
2876 * And we can also fail with pagereading if there are mandatory locks
2877 * on pages affected by this read but not on the region from pos to
2878 * pos+len-1.
2879 */
2880 if (!cinode->clientCanCacheRead)
2881 return cifs_user_readv(iocb, iov, nr_segs, pos);
2882
2883 if (cap_unix(tcon->ses) &&
2884 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2885 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2886 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2887
2888 /*
2889 * We need to hold the sem to be sure nobody modifies lock list
2890 * with a brlock that prevents reading.
2891 */
2892 down_read(&cinode->lock_sem);
2893 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2894 tcon->ses->server->vals->shared_lock_type,
2895 NULL, true))
2896 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2897 up_read(&cinode->lock_sem);
2898 return rc;
2899 }
2900
2901 static ssize_t
2902 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2903 {
2904 int rc = -EACCES;
2905 unsigned int bytes_read = 0;
2906 unsigned int total_read;
2907 unsigned int current_read_size;
2908 unsigned int rsize;
2909 struct cifs_sb_info *cifs_sb;
2910 struct cifs_tcon *tcon;
2911 struct TCP_Server_Info *server;
2912 unsigned int xid;
2913 char *cur_offset;
2914 struct cifsFileInfo *open_file;
2915 struct cifs_io_parms io_parms;
2916 int buf_type = CIFS_NO_BUFFER;
2917 __u32 pid;
2918
2919 xid = get_xid();
2920 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2921
2922 /* FIXME: set up handlers for larger reads and/or convert to async */
2923 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2924
2925 if (file->private_data == NULL) {
2926 rc = -EBADF;
2927 free_xid(xid);
2928 return rc;
2929 }
2930 open_file = file->private_data;
2931 tcon = tlink_tcon(open_file->tlink);
2932 server = tcon->ses->server;
2933
2934 if (!server->ops->sync_read) {
2935 free_xid(xid);
2936 return -ENOSYS;
2937 }
2938
2939 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2940 pid = open_file->pid;
2941 else
2942 pid = current->tgid;
2943
2944 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2945 cFYI(1, "attempting read on write only file instance");
2946
2947 for (total_read = 0, cur_offset = read_data; read_size > total_read;
2948 total_read += bytes_read, cur_offset += bytes_read) {
2949 current_read_size = min_t(uint, read_size - total_read, rsize);
2950 /*
2951 * For windows me and 9x we do not want to request more than it
2952 * negotiated since it will refuse the read then.
2953 */
2954 if ((tcon->ses) && !(tcon->ses->capabilities &
2955 tcon->ses->server->vals->cap_large_files)) {
2956 current_read_size = min_t(uint, current_read_size,
2957 CIFSMaxBufSize);
2958 }
2959 rc = -EAGAIN;
2960 while (rc == -EAGAIN) {
2961 if (open_file->invalidHandle) {
2962 rc = cifs_reopen_file(open_file, true);
2963 if (rc != 0)
2964 break;
2965 }
2966 io_parms.pid = pid;
2967 io_parms.tcon = tcon;
2968 io_parms.offset = *offset;
2969 io_parms.length = current_read_size;
2970 rc = server->ops->sync_read(xid, open_file, &io_parms,
2971 &bytes_read, &cur_offset,
2972 &buf_type);
2973 }
2974 if (rc || (bytes_read == 0)) {
2975 if (total_read) {
2976 break;
2977 } else {
2978 free_xid(xid);
2979 return rc;
2980 }
2981 } else {
2982 cifs_stats_bytes_read(tcon, total_read);
2983 *offset += bytes_read;
2984 }
2985 }
2986 free_xid(xid);
2987 return total_read;
2988 }
2989
2990 /*
2991 * If the page is mmap'ed into a process' page tables, then we need to make
2992 * sure that it doesn't change while being written back.
2993 */
2994 static int
2995 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2996 {
2997 struct page *page = vmf->page;
2998
2999 lock_page(page);
3000 return VM_FAULT_LOCKED;
3001 }
3002
3003 static struct vm_operations_struct cifs_file_vm_ops = {
3004 .fault = filemap_fault,
3005 .page_mkwrite = cifs_page_mkwrite,
3006 .remap_pages = generic_file_remap_pages,
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 };
Linux kernel - Deliverables
This page took 0.276576 seconds and 5 git commands to generate.