source: src/linux/universal/linux-3.18/fs/cifs/file.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

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