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