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