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