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