Merge tag '5.1-rc-smb3' of git://git.samba.org/sfrench/cifs-2.6
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 16 Mar 2019 01:52:12 +0000 (18:52 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 16 Mar 2019 01:52:12 +0000 (18:52 -0700)
Pull more smb3 updates from Steve French:
 "Various tracing and debugging improvements, crediting fixes, some
  cleanup, and important fallocate fix (fixes three xfstests) and lock
  fix.

  Summary:

   - Various additional dynamic tracing tracepoints

   - Debugging improvements (including ability to query the server via
     SMB3 fsctl from userspace tools which can help with stats and
     debugging)

   - One minor performance improvement (root directory inode caching)

   - Crediting (SMB3 flow control) fixes

   - Some cleanup (docs and to mknod)

   - Important fixes: one to smb3 implementation of fallocate zero range
     (which fixes three xfstests) and a POSIX lock fix"

* tag '5.1-rc-smb3' of git://git.samba.org/sfrench/cifs-2.6: (22 commits)
  CIFS: fix POSIX lock leak and invalid ptr deref
  SMB3: Allow SMB3 FSCTL queries to be sent to server from tools
  cifs: fix incorrect handling of smb2_set_sparse() return in smb3_simple_falloc
  smb2: fix typo in definition of a few error flags
  CIFS: make mknod() an smb_version_op
  cifs: minor documentation updates
  cifs: remove unused value pointed out by Coverity
  SMB3: passthru query info doesn't check for SMB3 FSCTL passthru
  smb3: add dynamic tracepoints for simple fallocate and zero range
  cifs: fix smb3_zero_range so it can expand the file-size when required
  cifs: add SMB2_ioctl_init/free helpers to be used with compounding
  smb3: Add dynamic trace points for various compounded smb3 ops
  cifs: cache FILE_ALL_INFO for the shared root handle
  smb3: display volume serial number for shares in /proc/fs/cifs/DebugData
  cifs: simplify how we handle credits in compound_send_recv()
  smb3: add dynamic tracepoint for timeout waiting for credits
  smb3: display security information in /proc/fs/cifs/DebugData more accurately
  cifs: add a timeout argument to wait_for_free_credits
  cifs: prevent starvation in wait_for_free_credits for multi-credit requests
  cifs: wait_for_free_credits() make it possible to wait for >=1 credits
  ...

17 files changed:
Documentation/filesystems/cifs/TODO
Documentation/filesystems/cifs/cifs.txt
fs/cifs/cifs_debug.c
fs/cifs/cifs_ioctl.h
fs/cifs/cifsglob.h
fs/cifs/connect.c
fs/cifs/dir.c
fs/cifs/file.c
fs/cifs/smb1ops.c
fs/cifs/smb2inode.c
fs/cifs/smb2ops.c
fs/cifs/smb2pdu.c
fs/cifs/smb2pdu.h
fs/cifs/smb2proto.h
fs/cifs/smb2status.h
fs/cifs/trace.h
fs/cifs/transport.c

index 66b3f54aa6dc48bacd70e646092669a2e1a323e8..9267f3fb131f9b5cf0e027ba9bdd9ff51a93d5b8 100644 (file)
@@ -111,7 +111,8 @@ negotiated size) and send larger write sizes to modern servers.
 
 5) Continue to extend the smb3 "buildbot" which does automated xfstesting
 against Windows, Samba and Azure currently - to add additional tests and
-to allow the buildbot to execute the tests faster.
+to allow the buildbot to execute the tests faster. The URL for the
+buildbot is: http://smb3-test-rhel-75.southcentralus.cloudapp.azure.com
 
 6) Address various coverity warnings (most are not bugs per-se, but
 the more warnings are addressed, the easier it is to spot real
index 67756607246e767a9105bc06c00a7b97730abbb1..1be3d21c286ece45d9024dfe9d718d46b5de66e0 100644 (file)
@@ -1,16 +1,21 @@
   This is the client VFS module for the SMB3 NAS protocol as well
-  older dialects such as the Common Internet File System (CIFS)
+  as for older dialects such as the Common Internet File System (CIFS)
   protocol which was the successor to the Server Message Block
   (SMB) protocol, the native file sharing mechanism for most early
   PC operating systems. New and improved versions of CIFS are now
-  called SMB2 and SMB3. These dialects are also supported by the
-  CIFS VFS module. CIFS is fully supported by network
-  file servers such as Windows 2000, 2003, 2008, 2012 and 2016
-  as well by Samba (which provides excellent CIFS
-  server support for Linux and many other operating systems), Apple
-  systems, as well as most Network Attached Storage vendors, so
-  this network filesystem client can mount to a wide variety of
-  servers.
+  called SMB2 and SMB3. Use of SMB3 (and later, including SMB3.1.1)
+  is strongly preferred over using older dialects like CIFS due to
+  security reaasons. All modern dialects, including the most recent,
+  SMB3.1.1 are supported by the CIFS VFS module. The SMB3 protocol
+  is implemented and supported by all major file servers
+  such as all modern versions of Windows (including Windows 2016
+  Server), as well as by Samba (which provides excellent
+  CIFS/SMB2/SMB3 server support and tools for Linux and many other
+  operating systems).  Apple systems also support SMB3 well, as
+  do most Network Attached Storage vendors, so this network
+  filesystem client can mount to a wide variety of systems.
+  It also supports mounting to the cloud (for example
+  Microsoft Azure), including the necessary security features.
 
   The intent of this module is to provide the most advanced network
   file system function for SMB3 compliant servers, including advanced
   cluster file systems for fileserving in some Linux to Linux environments,
   not just in Linux to Windows (or Linux to Mac) environments.
 
-  This filesystem has an mount utility (mount.cifs) that can be obtained from
+  This filesystem has a mount utility (mount.cifs) and various user space
+  tools (including smbinfo and setcifsacl) that can be obtained from
 
-      https://ftp.samba.org/pub/linux-cifs/cifs-utils/
+      https://git.samba.org/?p=cifs-utils.git
+  or
+      git://git.samba.org/cifs-utils.git
 
-  It must be installed in the directory with the other mount helpers.
+  mount.cifs should be installed in the directory with the other mount helpers.
 
   For more information on the module see the project wiki page at
 
+      https://wiki.samba.org/index.php/LinuxCIFS
+  and
       https://wiki.samba.org/index.php/LinuxCIFS_utils
index e92a2fee3c577bd7fc8c63e3e10edf079ca97686..13c1288b04a7318bde37f578e6a2c566fb692c07 100644 (file)
@@ -115,7 +115,12 @@ static void cifs_debug_tcon(struct seq_file *m, struct cifs_tcon *tcon)
                seq_puts(m, " type: CDROM ");
        else
                seq_printf(m, " type: %d ", dev_type);
-       if (tcon->seal)
+
+       seq_printf(m, "Serial Number: 0x%x", tcon->vol_serial_number);
+
+       if ((tcon->seal) ||
+           (tcon->ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) ||
+           (tcon->share_flags & SHI1005_FLAGS_ENCRYPT_DATA))
                seq_printf(m, " Encrypted");
        if (tcon->nocase)
                seq_printf(m, " nocase");
@@ -371,6 +376,10 @@ skip_rdma:
                                atomic_read(&server->in_send),
                                atomic_read(&server->num_waiters));
 #endif
+                       if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA)
+                               seq_puts(m, " encrypted");
+                       if (ses->sign)
+                               seq_puts(m, " signed");
 
                        seq_puts(m, "\n\tShares:");
                        j = 0;
index d8bce2f862de8ef756161eef30dd2e1d96725a0f..086ddc5108af7d0147eddd523e591a00c2e445cc 100644 (file)
@@ -43,6 +43,9 @@ struct smb_snapshot_array {
        /*      snapshots[]; */
 } __packed;
 
+/* query_info flags */
+#define PASSTHRU_QUERY_INFO    0x00000000
+#define PASSTHRU_FSCTL         0x00000001
 struct smb_query_info {
        __u32   info_type;
        __u32   file_info_class;
index f293e052e351de99e4ebad80cc9805375e5980b4..38feae812b4704b315ee3adfe2a1eaa2c4740e45 100644 (file)
@@ -479,6 +479,14 @@ struct smb_version_operations {
                                struct cifs_tcon *tcon,
                                __le16 *path, int is_dir,
                                unsigned long p);
+       /* make unix special files (block, char, fifo, socket) */
+       int (*make_node)(unsigned int xid,
+                        struct inode *inode,
+                        struct dentry *dentry,
+                        struct cifs_tcon *tcon,
+                        char *full_path,
+                        umode_t mode,
+                        dev_t device_number);
 };
 
 struct smb_version_values {
@@ -735,13 +743,13 @@ in_flight(struct TCP_Server_Info *server)
 }
 
 static inline bool
-has_credits(struct TCP_Server_Info *server, int *credits)
+has_credits(struct TCP_Server_Info *server, int *credits, int num_credits)
 {
        int num;
        spin_lock(&server->req_lock);
        num = *credits;
        spin_unlock(&server->req_lock);
-       return num > 0;
+       return num >= num_credits;
 }
 
 static inline void
@@ -962,11 +970,14 @@ cap_unix(struct cifs_ses *ses)
 
 struct cached_fid {
        bool is_valid:1;        /* Do we have a useable root fid */
+       bool file_all_info_is_valid:1;
+
        struct kref refcount;
        struct cifs_fid *fid;
        struct mutex fid_mutex;
        struct cifs_tcon *tcon;
        struct work_struct lease_break;
+       struct smb2_file_all_info file_all_info;
 };
 
 /*
@@ -1735,6 +1746,7 @@ require use of the stronger protocol */
  *  GlobalMid_Lock protects:
  *     list operations on pending_mid_q and oplockQ
  *      updates to XID counters, multiplex id  and SMB sequence numbers
+ *      list operations on global DnotifyReqList
  *  tcp_ses_lock protects:
  *     list operations on tcp and SMB session lists
  *  tcon->open_file_lock protects the list of open files hanging off the tcon
index b95db2b593cb078639ba71cfdcafe6c9d19c5a4b..a8e9738db691294736105bf8a0cd03772a9a2447 100644 (file)
@@ -1191,10 +1191,6 @@ next_pdu:
                        continue;
                }
 
-               if (server->large_buf)
-                       buf = server->bigbuf;
-
-
                server->lstrp = jiffies;
 
                for (i = 0; i < num_mids; i++) {
index 907e85d65bb4e09b5fdc8f7c1e6c35ef56b519ad..f26a48dd2e39508ab01c11c91d85fbb471beb16c 100644 (file)
@@ -621,20 +621,10 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
 {
        int rc = -EPERM;
        unsigned int xid;
-       int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
        struct cifs_sb_info *cifs_sb;
        struct tcon_link *tlink;
        struct cifs_tcon *tcon;
-       struct cifs_io_parms io_parms;
        char *full_path = NULL;
-       struct inode *newinode = NULL;
-       __u32 oplock = 0;
-       struct cifs_fid fid;
-       struct cifs_open_parms oparms;
-       FILE_ALL_INFO *buf = NULL;
-       unsigned int bytes_written;
-       struct win_dev *pdev;
-       struct kvec iov[2];
 
        if (!old_valid_dev(device_number))
                return -EINVAL;
@@ -654,103 +644,12 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
                goto mknod_out;
        }
 
-       if (tcon->unix_ext) {
-               struct cifs_unix_set_info_args args = {
-                       .mode   = mode & ~current_umask(),
-                       .ctime  = NO_CHANGE_64,
-                       .atime  = NO_CHANGE_64,
-                       .mtime  = NO_CHANGE_64,
-                       .device = device_number,
-               };
-               if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
-                       args.uid = current_fsuid();
-                       args.gid = current_fsgid();
-               } else {
-                       args.uid = INVALID_UID; /* no change */
-                       args.gid = INVALID_GID; /* no change */
-               }
-               rc = CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
-                                           cifs_sb->local_nls,
-                                           cifs_remap(cifs_sb));
-               if (rc)
-                       goto mknod_out;
-
-               rc = cifs_get_inode_info_unix(&newinode, full_path,
-                                               inode->i_sb, xid);
-
-               if (rc == 0)
-                       d_instantiate(direntry, newinode);
-               goto mknod_out;
-       }
-
-       if (!S_ISCHR(mode) && !S_ISBLK(mode))
-               goto mknod_out;
-
-       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
-               goto mknod_out;
-
-
-       cifs_dbg(FYI, "sfu compat create special file\n");
-
-       buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
-       if (buf == NULL) {
-               rc = -ENOMEM;
-               goto mknod_out;
-       }
-
-       if (backup_cred(cifs_sb))
-               create_options |= CREATE_OPEN_BACKUP_INTENT;
-
-       oparms.tcon = tcon;
-       oparms.cifs_sb = cifs_sb;
-       oparms.desired_access = GENERIC_WRITE;
-       oparms.create_options = create_options;
-       oparms.disposition = FILE_CREATE;
-       oparms.path = full_path;
-       oparms.fid = &fid;
-       oparms.reconnect = false;
-
-       if (tcon->ses->server->oplocks)
-               oplock = REQ_OPLOCK;
-       else
-               oplock = 0;
-       rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
-       if (rc)
-               goto mknod_out;
-
-       /*
-        * BB Do not bother to decode buf since no local inode yet to put
-        * timestamps in, but we can reuse it safely.
-        */
-
-       pdev = (struct win_dev *)buf;
-       io_parms.pid = current->tgid;
-       io_parms.tcon = tcon;
-       io_parms.offset = 0;
-       io_parms.length = sizeof(struct win_dev);
-       iov[1].iov_base = buf;
-       iov[1].iov_len = sizeof(struct win_dev);
-       if (S_ISCHR(mode)) {
-               memcpy(pdev->type, "IntxCHR", 8);
-               pdev->major = cpu_to_le64(MAJOR(device_number));
-               pdev->minor = cpu_to_le64(MINOR(device_number));
-               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
-                                                       &bytes_written, iov, 1);
-       } else if (S_ISBLK(mode)) {
-               memcpy(pdev->type, "IntxBLK", 8);
-               pdev->major = cpu_to_le64(MAJOR(device_number));
-               pdev->minor = cpu_to_le64(MINOR(device_number));
-               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
-                                                       &bytes_written, iov, 1);
-       }
-       tcon->ses->server->ops->close(xid, tcon, &fid);
-       d_drop(direntry);
-
-       /* FIXME: add code here to set EAs */
+       rc = tcon->ses->server->ops->make_node(xid, inode, direntry, tcon,
+                                              full_path, mode,
+                                              device_number);
 
 mknod_out:
        kfree(full_path);
-       kfree(buf);
        free_xid(xid);
        cifs_put_tlink(tlink);
        return rc;
index 4c144c1f50eb547d78076a1c2fd311f1fc6e5d28..2a6d20c0ce0288d37ad2405424200be3fefaa9f4 100644 (file)
@@ -1645,8 +1645,20 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                rc = server->ops->mand_unlock_range(cfile, flock, xid);
 
 out:
-       if (flock->fl_flags & FL_POSIX && !rc)
+       if (flock->fl_flags & FL_POSIX) {
+               /*
+                * If this is a request to remove all locks because we
+                * are closing the file, it doesn't matter if the
+                * unlocking failed as both cifs.ko and the SMB server
+                * remove the lock on file close
+                */
+               if (rc) {
+                       cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
+                       if (!(flock->fl_flags & FL_CLOSE))
+                               return rc;
+               }
                rc = locks_lock_file_wait(file, flock);
+       }
        return rc;
 }
 
index f0ce27c3c6e44e6a2c5a2f548dd09bd616443c85..c711f1f39bf2eaded7827d3ae29ae4b438328edf 100644 (file)
@@ -1027,6 +1027,131 @@ cifs_can_echo(struct TCP_Server_Info *server)
        return false;
 }
 
+static int
+cifs_make_node(unsigned int xid, struct inode *inode,
+              struct dentry *dentry, struct cifs_tcon *tcon,
+              char *full_path, umode_t mode, dev_t dev)
+{
+       struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+       struct inode *newinode = NULL;
+       int rc = -EPERM;
+       int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
+       FILE_ALL_INFO *buf = NULL;
+       struct cifs_io_parms io_parms;
+       __u32 oplock = 0;
+       struct cifs_fid fid;
+       struct cifs_open_parms oparms;
+       unsigned int bytes_written;
+       struct win_dev *pdev;
+       struct kvec iov[2];
+
+       if (tcon->unix_ext) {
+               /*
+                * SMB1 Unix Extensions: requires server support but
+                * works with all special files
+                */
+               struct cifs_unix_set_info_args args = {
+                       .mode   = mode & ~current_umask(),
+                       .ctime  = NO_CHANGE_64,
+                       .atime  = NO_CHANGE_64,
+                       .mtime  = NO_CHANGE_64,
+                       .device = dev,
+               };
+               if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
+                       args.uid = current_fsuid();
+                       args.gid = current_fsgid();
+               } else {
+                       args.uid = INVALID_UID; /* no change */
+                       args.gid = INVALID_GID; /* no change */
+               }
+               rc = CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
+                                           cifs_sb->local_nls,
+                                           cifs_remap(cifs_sb));
+               if (rc)
+                       goto out;
+
+               rc = cifs_get_inode_info_unix(&newinode, full_path,
+                                             inode->i_sb, xid);
+
+               if (rc == 0)
+                       d_instantiate(dentry, newinode);
+               goto out;
+       }
+
+       /*
+        * SMB1 SFU emulation: should work with all servers, but only
+        * support block and char device (no socket & fifo)
+        */
+       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
+               goto out;
+
+       if (!S_ISCHR(mode) && !S_ISBLK(mode))
+               goto out;
+
+       cifs_dbg(FYI, "sfu compat create special file\n");
+
+       buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
+       if (buf == NULL) {
+               rc = -ENOMEM;
+               goto out;
+       }
+
+       if (backup_cred(cifs_sb))
+               create_options |= CREATE_OPEN_BACKUP_INTENT;
+
+       oparms.tcon = tcon;
+       oparms.cifs_sb = cifs_sb;
+       oparms.desired_access = GENERIC_WRITE;
+       oparms.create_options = create_options;
+       oparms.disposition = FILE_CREATE;
+       oparms.path = full_path;
+       oparms.fid = &fid;
+       oparms.reconnect = false;
+
+       if (tcon->ses->server->oplocks)
+               oplock = REQ_OPLOCK;
+       else
+               oplock = 0;
+       rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
+       if (rc)
+               goto out;
+
+       /*
+        * BB Do not bother to decode buf since no local inode yet to put
+        * timestamps in, but we can reuse it safely.
+        */
+
+       pdev = (struct win_dev *)buf;
+       io_parms.pid = current->tgid;
+       io_parms.tcon = tcon;
+       io_parms.offset = 0;
+       io_parms.length = sizeof(struct win_dev);
+       iov[1].iov_base = buf;
+       iov[1].iov_len = sizeof(struct win_dev);
+       if (S_ISCHR(mode)) {
+               memcpy(pdev->type, "IntxCHR", 8);
+               pdev->major = cpu_to_le64(MAJOR(dev));
+               pdev->minor = cpu_to_le64(MINOR(dev));
+               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
+                                                       &bytes_written, iov, 1);
+       } else if (S_ISBLK(mode)) {
+               memcpy(pdev->type, "IntxBLK", 8);
+               pdev->major = cpu_to_le64(MAJOR(dev));
+               pdev->minor = cpu_to_le64(MINOR(dev));
+               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
+                                                       &bytes_written, iov, 1);
+       }
+       tcon->ses->server->ops->close(xid, tcon, &fid);
+       d_drop(dentry);
+
+       /* FIXME: add code here to set EAs */
+out:
+       kfree(buf);
+       return rc;
+}
+
+
+
 struct smb_version_operations smb1_operations = {
        .send_cancel = send_nt_cancel,
        .compare_fids = cifs_compare_fids,
@@ -1110,6 +1235,7 @@ struct smb_version_operations smb1_operations = {
        .get_acl_by_fid = get_cifs_acl_by_fid,
        .set_acl = set_cifs_acl,
 #endif /* CIFS_ACL */
+       .make_node = cifs_make_node,
 };
 
 struct smb_version_values smb1_values = {
index 01a76bccdb8dfd28c1a0fff2036270bea70f08db..278405d26c47e9f0f0cc6b4361af911a1fb1bd9e 100644 (file)
 #include "smb2pdu.h"
 #include "smb2proto.h"
 
+static void
+free_set_inf_compound(struct smb_rqst *rqst)
+{
+       if (rqst[1].rq_iov)
+               SMB2_set_info_free(&rqst[1]);
+       if (rqst[2].rq_iov)
+               SMB2_close_free(&rqst[2]);
+}
+
+
 static int
 smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                 struct cifs_sb_info *cifs_sb, const char *full_path,
@@ -112,14 +122,18 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                          PATH_MAX * 2, 0, NULL);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_query_info_compound_enter(xid, ses->Suid, tcon->tid,
+                                                    full_path);
                break;
        case SMB2_OP_DELETE:
+               trace_smb3_delete_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        case SMB2_OP_MKDIR:
                /*
                 * Directories are created through parameters in the
                 * SMB2_open() call.
                 */
+               trace_smb3_mkdir_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        case SMB2_OP_RMDIR:
                memset(&si_iov, 0, sizeof(si_iov));
@@ -135,6 +149,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                        SMB2_O_INFO_FILE, 0, data, size);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_rmdir_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        case SMB2_OP_SET_EOF:
                memset(&si_iov, 0, sizeof(si_iov));
@@ -150,6 +165,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                        SMB2_O_INFO_FILE, 0, data, size);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_set_eof_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        case SMB2_OP_SET_INFO:
                memset(&si_iov, 0, sizeof(si_iov));
@@ -166,6 +182,8 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                        SMB2_O_INFO_FILE, 0, data, size);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_set_info_compound_enter(xid, ses->Suid, tcon->tid,
+                                                  full_path);
                break;
        case SMB2_OP_RENAME:
                memset(&si_iov, 0, sizeof(si_iov));
@@ -190,6 +208,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                        SMB2_O_INFO_FILE, 0, data, size);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_rename_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        case SMB2_OP_HARDLINK:
                memset(&si_iov, 0, sizeof(si_iov));
@@ -214,6 +233,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                                        SMB2_O_INFO_FILE, 0, data, size);
                smb2_set_next_command(tcon, &rqst[num_rqst]);
                smb2_set_related(&rqst[num_rqst++]);
+               trace_smb3_hardlink_enter(xid, ses->Suid, tcon->tid, full_path);
                break;
        default:
                cifs_dbg(VFS, "Invalid command\n");
@@ -252,21 +272,65 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
                        SMB2_query_info_free(&rqst[1]);
                if (rqst[2].rq_iov)
                        SMB2_close_free(&rqst[2]);
+               if (rc)
+                       trace_smb3_query_info_compound_err(xid,  ses->Suid,
+                                               tcon->tid, rc);
+               else
+                       trace_smb3_query_info_compound_done(xid, ses->Suid,
+                                               tcon->tid);
                break;
        case SMB2_OP_DELETE:
+               if (rc)
+                       trace_smb3_delete_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_delete_done(xid, ses->Suid, tcon->tid);
+               if (rqst[1].rq_iov)
+                       SMB2_close_free(&rqst[1]);
+               break;
        case SMB2_OP_MKDIR:
+               if (rc)
+                       trace_smb3_mkdir_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_mkdir_done(xid, ses->Suid, tcon->tid);
                if (rqst[1].rq_iov)
                        SMB2_close_free(&rqst[1]);
                break;
        case SMB2_OP_HARDLINK:
+               if (rc)
+                       trace_smb3_hardlink_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_hardlink_done(xid, ses->Suid, tcon->tid);
+               free_set_inf_compound(rqst);
+               break;
        case SMB2_OP_RENAME:
+               if (rc)
+                       trace_smb3_rename_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_rename_done(xid, ses->Suid, tcon->tid);
+               free_set_inf_compound(rqst);
+               break;
        case SMB2_OP_RMDIR:
+               if (rc)
+                       trace_smb3_rmdir_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_rmdir_done(xid, ses->Suid, tcon->tid);
+               free_set_inf_compound(rqst);
+               break;
        case SMB2_OP_SET_EOF:
+               if (rc)
+                       trace_smb3_set_eof_err(xid,  ses->Suid, tcon->tid, rc);
+               else
+                       trace_smb3_set_eof_done(xid, ses->Suid, tcon->tid);
+               free_set_inf_compound(rqst);
+               break;
        case SMB2_OP_SET_INFO:
-               if (rqst[1].rq_iov)
-                       SMB2_set_info_free(&rqst[1]);
-               if (rqst[2].rq_iov)
-                       SMB2_close_free(&rqst[2]);
+               if (rc)
+                       trace_smb3_set_info_compound_err(xid,  ses->Suid,
+                                               tcon->tid, rc);
+               else
+                       trace_smb3_set_info_compound_done(xid, ses->Suid,
+                                               tcon->tid);
+               free_set_inf_compound(rqst);
                break;
        }
        free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
@@ -309,12 +373,17 @@ smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
                rc = open_shroot(xid, tcon, &fid);
                if (rc)
                        goto out;
-               rc = SMB2_query_info(xid, tcon, fid.persistent_fid,
-                                    fid.volatile_fid, smb2_data);
+
+               if (tcon->crfid.file_all_info_is_valid) {
+                       move_smb2_info_to_cifs(data,
+                                              &tcon->crfid.file_all_info);
+               } else {
+                       rc = SMB2_query_info(xid, tcon, fid.persistent_fid,
+                                            fid.volatile_fid, smb2_data);
+                       if (!rc)
+                               move_smb2_info_to_cifs(data, smb2_data);
+               }
                close_shroot(&tcon->crfid);
-               if (rc)
-                       goto out;
-               move_smb2_info_to_cifs(data, smb2_data);
                goto out;
        }
 
index 085e91436da7e6d24b89e87ba753b9b672b89f6a..1022a3771e140d819e767ba5a75677a88d65f911 100644 (file)
@@ -185,7 +185,7 @@ smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
                        spin_unlock(&server->req_lock);
                        cifs_num_waiters_inc(server);
                        rc = wait_event_killable(server->request_q,
-                                       has_credits(server, &server->credits));
+                               has_credits(server, &server->credits, 1));
                        cifs_num_waiters_dec(server);
                        if (rc)
                                return rc;
@@ -619,6 +619,7 @@ smb2_close_cached_fid(struct kref *ref)
                SMB2_close(0, cfid->tcon, cfid->fid->persistent_fid,
                           cfid->fid->volatile_fid);
                cfid->is_valid = false;
+               cfid->file_all_info_is_valid = false;
        }
 }
 
@@ -643,9 +644,18 @@ smb2_cached_lease_break(struct work_struct *work)
  */
 int open_shroot(unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *pfid)
 {
-       struct cifs_open_parms oparams;
-       int rc;
-       __le16 srch_path = 0; /* Null - since an open of top of share */
+       struct cifs_ses *ses = tcon->ses;
+       struct TCP_Server_Info *server = ses->server;
+       struct cifs_open_parms oparms;
+       struct smb2_create_rsp *o_rsp = NULL;
+       struct smb2_query_info_rsp *qi_rsp = NULL;
+       int resp_buftype[2];
+       struct smb_rqst rqst[2];
+       struct kvec rsp_iov[2];
+       struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
+       struct kvec qi_iov[1];
+       int rc, flags = 0;
+       __le16 utf16_path = 0; /* Null - since an open of top of share */
        u8 oplock = SMB2_OPLOCK_LEVEL_II;
 
        mutex_lock(&tcon->crfid.fid_mutex);
@@ -657,22 +667,89 @@ int open_shroot(unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *pfid)
                return 0;
        }
 
-       oparams.tcon = tcon;
-       oparams.create_options = 0;
-       oparams.desired_access = FILE_READ_ATTRIBUTES;
-       oparams.disposition = FILE_OPEN;
-       oparams.fid = pfid;
-       oparams.reconnect = false;
-
-       rc = SMB2_open(xid, &oparams, &srch_path, &oplock, NULL, NULL, NULL);
-       if (rc == 0) {
-               memcpy(tcon->crfid.fid, pfid, sizeof(struct cifs_fid));
-               tcon->crfid.tcon = tcon;
-               tcon->crfid.is_valid = true;
-               kref_init(&tcon->crfid.refcount);
-               kref_get(&tcon->crfid.refcount);
-       }
+       if (smb3_encryption_required(tcon))
+               flags |= CIFS_TRANSFORM_REQ;
+
+       memset(rqst, 0, sizeof(rqst));
+       resp_buftype[0] = resp_buftype[1] = CIFS_NO_BUFFER;
+       memset(rsp_iov, 0, sizeof(rsp_iov));
+
+       /* Open */
+       memset(&open_iov, 0, sizeof(open_iov));
+       rqst[0].rq_iov = open_iov;
+       rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
+
+       oparms.tcon = tcon;
+       oparms.create_options = 0;
+       oparms.desired_access = FILE_READ_ATTRIBUTES;
+       oparms.disposition = FILE_OPEN;
+       oparms.fid = pfid;
+       oparms.reconnect = false;
+
+       rc = SMB2_open_init(tcon, &rqst[0], &oplock, &oparms, &utf16_path);
+       if (rc)
+               goto oshr_exit;
+       smb2_set_next_command(tcon, &rqst[0]);
+
+       memset(&qi_iov, 0, sizeof(qi_iov));
+       rqst[1].rq_iov = qi_iov;
+       rqst[1].rq_nvec = 1;
+
+       rc = SMB2_query_info_init(tcon, &rqst[1], COMPOUND_FID,
+                                 COMPOUND_FID, FILE_ALL_INFORMATION,
+                                 SMB2_O_INFO_FILE, 0,
+                                 sizeof(struct smb2_file_all_info) +
+                                 PATH_MAX * 2, 0, NULL);
+       if (rc)
+               goto oshr_exit;
+
+       smb2_set_related(&rqst[1]);
+
+       rc = compound_send_recv(xid, ses, flags, 2, rqst,
+                               resp_buftype, rsp_iov);
+       if (rc)
+               goto oshr_exit;
+
+       o_rsp = (struct smb2_create_rsp *)rsp_iov[0].iov_base;
+       oparms.fid->persistent_fid = o_rsp->PersistentFileId;
+       oparms.fid->volatile_fid = o_rsp->VolatileFileId;
+#ifdef CONFIG_CIFS_DEBUG2
+       oparms.fid->mid = le64_to_cpu(o_rsp->sync_hdr.MessageId);
+#endif /* CIFS_DEBUG2 */
+
+       if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE)
+               oplock = smb2_parse_lease_state(server, o_rsp,
+                                               &oparms.fid->epoch,
+                                               oparms.fid->lease_key);
+       else
+               goto oshr_exit;
+
+
+       memcpy(tcon->crfid.fid, pfid, sizeof(struct cifs_fid));
+       tcon->crfid.tcon = tcon;
+       tcon->crfid.is_valid = true;
+       kref_init(&tcon->crfid.refcount);
+       kref_get(&tcon->crfid.refcount);
+
+
+       qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
+       if (le32_to_cpu(qi_rsp->OutputBufferLength) < sizeof(struct smb2_file_all_info))
+               goto oshr_exit;
+       rc = smb2_validate_and_copy_iov(
+                               le16_to_cpu(qi_rsp->OutputBufferOffset),
+                               sizeof(struct smb2_file_all_info),
+                               &rsp_iov[1], sizeof(struct smb2_file_all_info),
+                               (char *)&tcon->crfid.file_all_info);
+       if (rc)
+               goto oshr_exit;
+       tcon->crfid.file_all_info_is_valid = 1;
+
+ oshr_exit:
        mutex_unlock(&tcon->crfid.fid_mutex);
+       SMB2_open_free(&rqst[0]);
+       SMB2_query_info_free(&rqst[1]);
+       free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
+       free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
        return rc;
 }
 
@@ -1253,7 +1330,8 @@ smb2_ioctl_query_info(const unsigned int xid,
        struct smb_query_info __user *pqi;
        int rc = 0;
        int flags = 0;
-       struct smb2_query_info_rsp *rsp = NULL;
+       struct smb2_query_info_rsp *qi_rsp = NULL;
+       struct smb2_ioctl_rsp *io_rsp = NULL;
        void *buffer = NULL;
        struct smb_rqst rqst[3];
        int resp_buftype[3];
@@ -1263,6 +1341,7 @@ smb2_ioctl_query_info(const unsigned int xid,
        u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
        struct cifs_fid fid;
        struct kvec qi_iov[1];
+       struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];
        struct kvec close_iov[1];
 
        memset(rqst, 0, sizeof(rqst));
@@ -1313,15 +1392,35 @@ smb2_ioctl_query_info(const unsigned int xid,
        smb2_set_next_command(tcon, &rqst[0]);
 
        /* Query */
-       memset(&qi_iov, 0, sizeof(qi_iov));
-       rqst[1].rq_iov = qi_iov;
-       rqst[1].rq_nvec = 1;
-
-       rc = SMB2_query_info_init(tcon, &rqst[1], COMPOUND_FID, COMPOUND_FID,
-                                 qi.file_info_class, qi.info_type,
-                                 qi.additional_information,
+       if (qi.flags & PASSTHRU_FSCTL) {
+               /* Can eventually relax perm check since server enforces too */
+               if (!capable(CAP_SYS_ADMIN))
+                       rc = -EPERM;
+               else  {
+                       memset(&io_iov, 0, sizeof(io_iov));
+                       rqst[1].rq_iov = io_iov;
+                       rqst[1].rq_nvec = SMB2_IOCTL_IOV_SIZE;
+
+                       rc = SMB2_ioctl_init(tcon, &rqst[1],
+                                            COMPOUND_FID, COMPOUND_FID,
+                                            qi.info_type, true, NULL,
+                                            0);
+               }
+       } else if (qi.flags == PASSTHRU_QUERY_INFO) {
+               memset(&qi_iov, 0, sizeof(qi_iov));
+               rqst[1].rq_iov = qi_iov;
+               rqst[1].rq_nvec = 1;
+
+               rc = SMB2_query_info_init(tcon, &rqst[1], COMPOUND_FID,
+                                 COMPOUND_FID, qi.file_info_class,
+                                 qi.info_type, qi.additional_information,
                                  qi.input_buffer_length,
                                  qi.output_buffer_length, buffer);
+       } else { /* unknown flags */
+               cifs_dbg(VFS, "invalid passthru query flags: 0x%x\n", qi.flags);
+               rc = -EINVAL;
+       }
+
        if (rc)
                goto iqinf_exit;
        smb2_set_next_command(tcon, &rqst[1]);
@@ -1341,24 +1440,44 @@ smb2_ioctl_query_info(const unsigned int xid,
                                resp_buftype, rsp_iov);
        if (rc)
                goto iqinf_exit;
-       pqi = (struct smb_query_info __user *)arg;
-       rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
-       if (le32_to_cpu(rsp->OutputBufferLength) < qi.input_buffer_length)
-               qi.input_buffer_length = le32_to_cpu(rsp->OutputBufferLength);
-       if (copy_to_user(&pqi->input_buffer_length, &qi.input_buffer_length,
-                        sizeof(qi.input_buffer_length))) {
-               rc = -EFAULT;
-               goto iqinf_exit;
-       }
-       if (copy_to_user(pqi + 1, rsp->Buffer, qi.input_buffer_length)) {
-               rc = -EFAULT;
-               goto iqinf_exit;
+       if (qi.flags & PASSTHRU_FSCTL) {
+               pqi = (struct smb_query_info __user *)arg;
+               io_rsp = (struct smb2_ioctl_rsp *)rsp_iov[1].iov_base;
+               if (le32_to_cpu(io_rsp->OutputCount) < qi.input_buffer_length)
+                       qi.input_buffer_length = le32_to_cpu(io_rsp->OutputCount);
+               if (copy_to_user(&pqi->input_buffer_length, &qi.input_buffer_length,
+                                sizeof(qi.input_buffer_length))) {
+                       rc = -EFAULT;
+                       goto iqinf_exit;
+               }
+               if (copy_to_user(pqi + 1, &io_rsp[1], qi.input_buffer_length)) {
+                       rc = -EFAULT;
+                       goto iqinf_exit;
+               }
+       } else {
+               pqi = (struct smb_query_info __user *)arg;
+               qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
+               if (le32_to_cpu(qi_rsp->OutputBufferLength) < qi.input_buffer_length)
+                       qi.input_buffer_length = le32_to_cpu(qi_rsp->OutputBufferLength);
+               if (copy_to_user(&pqi->input_buffer_length, &qi.input_buffer_length,
+                                sizeof(qi.input_buffer_length))) {
+                       rc = -EFAULT;
+                       goto iqinf_exit;
+               }
+               if (copy_to_user(pqi + 1, qi_rsp->Buffer, qi.input_buffer_length)) {
+                       rc = -EFAULT;
+                       goto iqinf_exit;
+               }
        }
 
  iqinf_exit:
        kfree(buffer);
        SMB2_open_free(&rqst[0]);
-       SMB2_query_info_free(&rqst[1]);
+       if (qi.flags & PASSTHRU_FSCTL)
+               SMB2_ioctl_free(&rqst[1]);
+       else
+               SMB2_query_info_free(&rqst[1]);
+
        SMB2_close_free(&rqst[2]);
        free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
        free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
@@ -2472,22 +2591,38 @@ get_smb2_acl(struct cifs_sb_info *cifs_sb,
 static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
                            loff_t offset, loff_t len, bool keep_size)
 {
+       struct cifs_ses *ses = tcon->ses;
        struct inode *inode;
        struct cifsInodeInfo *cifsi;
        struct cifsFileInfo *cfile = file->private_data;
        struct file_zero_data_information fsctl_buf;
+       struct smb_rqst rqst[2];
+       int resp_buftype[2];
+       struct kvec rsp_iov[2];
+       struct kvec io_iov[SMB2_IOCTL_IOV_SIZE];
+       struct kvec si_iov[1];
+       unsigned int size[1];
+       void *data[1];
        long rc;
        unsigned int xid;
+       int num = 0, flags = 0;
+       __le64 eof;
 
        xid = get_xid();
 
        inode = d_inode(cfile->dentry);
        cifsi = CIFS_I(inode);
 
+        trace_smb3_zero_enter(xid, cfile->fid.persistent_fid, tcon->tid,
+                             ses->Suid, offset, len);
+
+
        /* if file not oplocked can't be sure whether asking to extend size */
        if (!CIFS_CACHE_READ(cifsi))
                if (keep_size == false) {
                        rc = -EOPNOTSUPP;
+                       trace_smb3_zero_err(xid, cfile->fid.persistent_fid,
+                               tcon->tid, ses->Suid, offset, len, rc);
                        free_xid(xid);
                        return rc;
                }
@@ -2498,33 +2633,73 @@ static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
         */
        if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) {
                rc = -EOPNOTSUPP;
+               trace_smb3_zero_err(xid, cfile->fid.persistent_fid, tcon->tid,
+                             ses->Suid, offset, len, rc);
                free_xid(xid);
                return rc;
        }
 
-       /*
-        * need to make sure we are not asked to extend the file since the SMB3
-        * fsctl does not change the file size. In the future we could change
-        * this to zero the first part of the range then set the file size
-        * which for a non sparse file would zero the newly extended range
-        */
-       if (keep_size == false)
-               if (i_size_read(inode) < offset + len) {
-                       rc = -EOPNOTSUPP;
-                       free_xid(xid);
-                       return rc;
-               }
-
        cifs_dbg(FYI, "offset %lld len %lld", offset, len);
 
        fsctl_buf.FileOffset = cpu_to_le64(offset);
        fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len);
 
-       rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
-                       cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
-                       true /* is_fctl */, (char *)&fsctl_buf,
-                       sizeof(struct file_zero_data_information), NULL, NULL);
+       if (smb3_encryption_required(tcon))
+               flags |= CIFS_TRANSFORM_REQ;
+
+       memset(rqst, 0, sizeof(rqst));
+       resp_buftype[0] = resp_buftype[1] = CIFS_NO_BUFFER;
+       memset(rsp_iov, 0, sizeof(rsp_iov));
+
+
+       memset(&io_iov, 0, sizeof(io_iov));
+       rqst[num].rq_iov = io_iov;
+       rqst[num].rq_nvec = SMB2_IOCTL_IOV_SIZE;
+       rc = SMB2_ioctl_init(tcon, &rqst[num++], cfile->fid.persistent_fid,
+                            cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
+                            true /* is_fctl */, (char *)&fsctl_buf,
+                            sizeof(struct file_zero_data_information));
+       if (rc)
+               goto zero_range_exit;
+
+       /*
+        * do we also need to change the size of the file?
+        */
+       if (keep_size == false && i_size_read(inode) < offset + len) {
+               smb2_set_next_command(tcon, &rqst[0]);
+
+               memset(&si_iov, 0, sizeof(si_iov));
+               rqst[num].rq_iov = si_iov;
+               rqst[num].rq_nvec = 1;
+
+               eof = cpu_to_le64(offset + len);
+               size[0] = 8; /* sizeof __le64 */
+               data[0] = &eof;
+
+               rc = SMB2_set_info_init(tcon, &rqst[num++],
+                                       cfile->fid.persistent_fid,
+                                       cfile->fid.persistent_fid,
+                                       current->tgid,
+                                       FILE_END_OF_FILE_INFORMATION,
+                                       SMB2_O_INFO_FILE, 0, data, size);
+               smb2_set_related(&rqst[1]);
+       }
+
+       rc = compound_send_recv(xid, ses, flags, num, rqst,
+                               resp_buftype, rsp_iov);
+
+ zero_range_exit:
+       SMB2_ioctl_free(&rqst[0]);
+       SMB2_set_info_free(&rqst[1]);
+       free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
+       free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
        free_xid(xid);
+       if (rc)
+               trace_smb3_zero_err(xid, cfile->fid.persistent_fid, tcon->tid,
+                             ses->Suid, offset, len, rc);
+       else
+               trace_smb3_zero_done(xid, cfile->fid.persistent_fid, tcon->tid,
+                             ses->Suid, offset, len);
        return rc;
 }
 
@@ -2573,15 +2748,20 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
        struct cifsFileInfo *cfile = file->private_data;
        long rc = -EOPNOTSUPP;
        unsigned int xid;
+       __le64 eof;
 
        xid = get_xid();
 
        inode = d_inode(cfile->dentry);
        cifsi = CIFS_I(inode);
 
+       trace_smb3_falloc_enter(xid, cfile->fid.persistent_fid, tcon->tid,
+                               tcon->ses->Suid, off, len);
        /* if file not oplocked can't be sure whether asking to extend size */
        if (!CIFS_CACHE_READ(cifsi))
                if (keep_size == false) {
+                       trace_smb3_falloc_err(xid, cfile->fid.persistent_fid,
+                               tcon->tid, tcon->ses->Suid, off, len, rc);
                        free_xid(xid);
                        return rc;
                }
@@ -2601,6 +2781,12 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
                /* BB: in future add else clause to extend file */
                else
                        rc = -EOPNOTSUPP;
+               if (rc)
+                       trace_smb3_falloc_err(xid, cfile->fid.persistent_fid,
+                               tcon->tid, tcon->ses->Suid, off, len, rc);
+               else
+                       trace_smb3_falloc_done(xid, cfile->fid.persistent_fid,
+                               tcon->tid, tcon->ses->Suid, off, len);
                free_xid(xid);
                return rc;
        }
@@ -2616,14 +2802,31 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
                 */
                if ((off > 8192) || (off + len + 8192 < i_size_read(inode))) {
                        rc = -EOPNOTSUPP;
+                       trace_smb3_falloc_err(xid, cfile->fid.persistent_fid,
+                               tcon->tid, tcon->ses->Suid, off, len, rc);
                        free_xid(xid);
                        return rc;
                }
 
-               rc = smb2_set_sparse(xid, tcon, cfile, inode, false);
+               smb2_set_sparse(xid, tcon, cfile, inode, false);
+               rc = 0;
+       } else {
+               smb2_set_sparse(xid, tcon, cfile, inode, false);
+               rc = 0;
+               if (i_size_read(inode) < off + len) {
+                       eof = cpu_to_le64(off + len);
+                       rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid,
+                                         cfile->fid.volatile_fid, cfile->pid,
+                                         &eof);
+               }
        }
-       /* BB: else ... in future add code to extend file and set sparse */
 
+       if (rc)
+               trace_smb3_falloc_err(xid, cfile->fid.persistent_fid, tcon->tid,
+                               tcon->ses->Suid, off, len, rc);
+       else
+               trace_smb3_falloc_done(xid, cfile->fid.persistent_fid, tcon->tid,
+                               tcon->ses->Suid, off, len);
 
        free_xid(xid);
        return rc;
@@ -3604,6 +3807,104 @@ smb2_next_header(char *buf)
        return le32_to_cpu(hdr->NextCommand);
 }
 
+static int
+smb2_make_node(unsigned int xid, struct inode *inode,
+              struct dentry *dentry, struct cifs_tcon *tcon,
+              char *full_path, umode_t mode, dev_t dev)
+{
+       struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+       int rc = -EPERM;
+       int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
+       FILE_ALL_INFO *buf = NULL;
+       struct cifs_io_parms io_parms;
+       __u32 oplock = 0;
+       struct cifs_fid fid;
+       struct cifs_open_parms oparms;
+       unsigned int bytes_written;
+       struct win_dev *pdev;
+       struct kvec iov[2];
+
+       /*
+        * Check if mounted with mount parm 'sfu' mount parm.
+        * SFU emulation should work with all servers, but only
+        * supports block and char device (no socket & fifo),
+        * and was used by default in earlier versions of Windows
+        */
+       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
+               goto out;
+
+       /*
+        * TODO: Add ability to create instead via reparse point. Windows (e.g.
+        * their current NFS server) uses this approach to expose special files
+        * over SMB2/SMB3 and Samba will do this with SMB3.1.1 POSIX Extensions
+        */
+
+       if (!S_ISCHR(mode) && !S_ISBLK(mode))
+               goto out;
+
+       cifs_dbg(FYI, "sfu compat create special file\n");
+
+       buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
+       if (buf == NULL) {
+               rc = -ENOMEM;
+               goto out;
+       }
+
+       if (backup_cred(cifs_sb))
+               create_options |= CREATE_OPEN_BACKUP_INTENT;
+
+       oparms.tcon = tcon;
+       oparms.cifs_sb = cifs_sb;
+       oparms.desired_access = GENERIC_WRITE;
+       oparms.create_options = create_options;
+       oparms.disposition = FILE_CREATE;
+       oparms.path = full_path;
+       oparms.fid = &fid;
+       oparms.reconnect = false;
+
+       if (tcon->ses->server->oplocks)
+               oplock = REQ_OPLOCK;
+       else
+               oplock = 0;
+       rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
+       if (rc)
+               goto out;
+
+       /*
+        * BB Do not bother to decode buf since no local inode yet to put
+        * timestamps in, but we can reuse it safely.
+        */
+
+       pdev = (struct win_dev *)buf;
+       io_parms.pid = current->tgid;
+       io_parms.tcon = tcon;
+       io_parms.offset = 0;
+       io_parms.length = sizeof(struct win_dev);
+       iov[1].iov_base = buf;
+       iov[1].iov_len = sizeof(struct win_dev);
+       if (S_ISCHR(mode)) {
+               memcpy(pdev->type, "IntxCHR", 8);
+               pdev->major = cpu_to_le64(MAJOR(dev));
+               pdev->minor = cpu_to_le64(MINOR(dev));
+               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
+                                                       &bytes_written, iov, 1);
+       } else if (S_ISBLK(mode)) {
+               memcpy(pdev->type, "IntxBLK", 8);
+               pdev->major = cpu_to_le64(MAJOR(dev));
+               pdev->minor = cpu_to_le64(MINOR(dev));
+               rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
+                                                       &bytes_written, iov, 1);
+       }
+       tcon->ses->server->ops->close(xid, tcon, &fid);
+       d_drop(dentry);
+
+       /* FIXME: add code here to set EAs */
+out:
+       kfree(buf);
+       return rc;
+}
+
+
 struct smb_version_operations smb20_operations = {
        .compare_fids = smb2_compare_fids,
        .setup_request = smb2_setup_request,
@@ -3698,6 +3999,7 @@ struct smb_version_operations smb20_operations = {
 #endif /* CIFS_ACL */
        .next_header = smb2_next_header,
        .ioctl_query_info = smb2_ioctl_query_info,
+       .make_node = smb2_make_node,
 };
 
 struct smb_version_operations smb21_operations = {
@@ -3796,6 +4098,7 @@ struct smb_version_operations smb21_operations = {
 #endif /* CIFS_ACL */
        .next_header = smb2_next_header,
        .ioctl_query_info = smb2_ioctl_query_info,
+       .make_node = smb2_make_node,
 };
 
 struct smb_version_operations smb30_operations = {
@@ -3903,6 +4206,7 @@ struct smb_version_operations smb30_operations = {
 #endif /* CIFS_ACL */
        .next_header = smb2_next_header,
        .ioctl_query_info = smb2_ioctl_query_info,
+       .make_node = smb2_make_node,
 };
 
 struct smb_version_operations smb311_operations = {
@@ -4011,6 +4315,7 @@ struct smb_version_operations smb311_operations = {
 #endif /* CIFS_ACL */
        .next_header = smb2_next_header,
        .ioctl_query_info = smb2_ioctl_query_info,
+       .make_node = smb2_make_node,
 };
 
 struct smb_version_values smb20_values = {
index 60fbe306f60431b40554d916d1ee8ba7351ebe27..c399e09b76e62a7c733857075ff348b039e49a58 100644 (file)
@@ -1797,9 +1797,10 @@ create_reconnect_durable_buf(struct cifs_fid *fid)
        return buf;
 }
 
-static __u8
-parse_lease_state(struct TCP_Server_Info *server, struct smb2_create_rsp *rsp,
-                 unsigned int *epoch, char *lease_key)
+__u8
+smb2_parse_lease_state(struct TCP_Server_Info *server,
+                      struct smb2_create_rsp *rsp,
+                      unsigned int *epoch, char *lease_key)
 {
        char *data_offset;
        struct create_context *cc;
@@ -2456,8 +2457,9 @@ SMB2_open(const unsigned int xid, struct cifs_open_parms *oparms, __le16 *path,
        }
 
        if (rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE)
-               *oplock = parse_lease_state(server, rsp, &oparms->fid->epoch,
-                                           oparms->fid->lease_key);
+               *oplock = smb2_parse_lease_state(server, rsp,
+                                                &oparms->fid->epoch,
+                                                oparms->fid->lease_key);
        else
                *oplock = rsp->OplockLevel;
 creat_exit:
@@ -2466,65 +2468,46 @@ creat_exit:
        return rc;
 }
 
-/*
- *     SMB2 IOCTL is used for both IOCTLs and FSCTLs
- */
 int
-SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
-          u64 volatile_fid, u32 opcode, bool is_fsctl,
-          char *in_data, u32 indatalen,
-          char **out_data, u32 *plen /* returned data len */)
+SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst,
+               u64 persistent_fid, u64 volatile_fid, u32 opcode,
+               bool is_fsctl, char *in_data, u32 indatalen)
 {
-       struct smb_rqst rqst;
        struct smb2_ioctl_req *req;
-       struct smb2_ioctl_rsp *rsp;
-       struct cifs_ses *ses;
-       struct kvec iov[2];
-       struct kvec rsp_iov;
-       int resp_buftype;
-       int n_iov;
-       int rc = 0;
-       int flags = 0;
+       struct kvec *iov = rqst->rq_iov;
        unsigned int total_len;
-
-       cifs_dbg(FYI, "SMB2 IOCTL\n");
-
-       if (out_data != NULL)
-               *out_data = NULL;
-
-       /* zero out returned data len, in case of error */
-       if (plen)
-               *plen = 0;
-
-       if (tcon)
-               ses = tcon->ses;
-       else
-               return -EIO;
-
-       if (!ses || !(ses->server))
-               return -EIO;
+       int rc;
 
        rc = smb2_plain_req_init(SMB2_IOCTL, tcon, (void **) &req, &total_len);
        if (rc)
                return rc;
 
-       if (smb3_encryption_required(tcon))
-               flags |= CIFS_TRANSFORM_REQ;
-
        req->CtlCode = cpu_to_le32(opcode);
        req->PersistentFileId = persistent_fid;
        req->VolatileFileId = volatile_fid;
 
+       iov[0].iov_base = (char *)req;
+       /*
+        * If no input data, the size of ioctl struct in
+        * protocol spec still includes a 1 byte data buffer,
+        * but if input data passed to ioctl, we do not
+        * want to double count this, so we do not send
+        * the dummy one byte of data in iovec[0] if sending
+        * input data (in iovec[1]).
+        */
        if (indatalen) {
                req->InputCount = cpu_to_le32(indatalen);
                /* do not set InputOffset if no input data */
                req->InputOffset =
                       cpu_to_le32(offsetof(struct smb2_ioctl_req, Buffer));
+               rqst->rq_nvec = 2;
+               iov[0].iov_len = total_len - 1;
                iov[1].iov_base = in_data;
                iov[1].iov_len = indatalen;
-               n_iov = 2;
-       } else
-               n_iov = 1;
+       } else {
+               rqst->rq_nvec = 1;
+               iov[0].iov_len = total_len;
+       }
 
        req->OutputOffset = 0;
        req->OutputCount = 0; /* MBZ */
@@ -2546,33 +2529,70 @@ SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
        else
                req->Flags = 0;
 
-       iov[0].iov_base = (char *)req;
-
-       /*
-        * If no input data, the size of ioctl struct in
-        * protocol spec still includes a 1 byte data buffer,
-        * but if input data passed to ioctl, we do not
-        * want to double count this, so we do not send
-        * the dummy one byte of data in iovec[0] if sending
-        * input data (in iovec[1]).
-        */
-
-       if (indatalen) {
-               iov[0].iov_len = total_len - 1;
-       } else
-               iov[0].iov_len = total_len;
-
        /* validate negotiate request must be signed - see MS-SMB2 3.2.5.5 */
        if (opcode == FSCTL_VALIDATE_NEGOTIATE_INFO)
                req->sync_hdr.Flags |= SMB2_FLAGS_SIGNED;
 
+       return 0;
+}
+
+void
+SMB2_ioctl_free(struct smb_rqst *rqst)
+{
+       if (rqst && rqst->rq_iov)
+               cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */
+}
+
+/*
+ *     SMB2 IOCTL is used for both IOCTLs and FSCTLs
+ */
+int
+SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
+          u64 volatile_fid, u32 opcode, bool is_fsctl,
+          char *in_data, u32 indatalen,
+          char **out_data, u32 *plen /* returned data len */)
+{
+       struct smb_rqst rqst;
+       struct smb2_ioctl_rsp *rsp = NULL;
+       struct cifs_ses *ses;
+       struct kvec iov[SMB2_IOCTL_IOV_SIZE];
+       struct kvec rsp_iov = {NULL, 0};
+       int resp_buftype = CIFS_NO_BUFFER;
+       int rc = 0;
+       int flags = 0;
+
+       cifs_dbg(FYI, "SMB2 IOCTL\n");
+
+       if (out_data != NULL)
+               *out_data = NULL;
+
+       /* zero out returned data len, in case of error */
+       if (plen)
+               *plen = 0;
+
+       if (tcon)
+               ses = tcon->ses;
+       else
+               return -EIO;
+
+       if (!ses || !(ses->server))
+               return -EIO;
+
+       if (smb3_encryption_required(tcon))
+               flags |= CIFS_TRANSFORM_REQ;
+
        memset(&rqst, 0, sizeof(struct smb_rqst));
+       memset(&iov, 0, sizeof(iov));
        rqst.rq_iov = iov;
-       rqst.rq_nvec = n_iov;
+       rqst.rq_nvec = SMB2_IOCTL_IOV_SIZE;
+
+       rc = SMB2_ioctl_init(tcon, &rqst, persistent_fid, volatile_fid,
+                            opcode, is_fsctl, in_data, indatalen);
+       if (rc)
+               goto ioctl_exit;
 
        rc = cifs_send_recv(xid, ses, &rqst, &resp_buftype, flags,
                            &rsp_iov);
-       cifs_small_buf_release(req);
        rsp = (struct smb2_ioctl_rsp *)rsp_iov.iov_base;
 
        if (rc != 0)
@@ -2622,6 +2642,7 @@ SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
        }
 
 ioctl_exit:
+       SMB2_ioctl_free(&rqst);
        free_rsp_buf(resp_buftype, rsp);
        return rc;
 }
index 0bd4d4802701320e73bc795730002b729688b732..ee8977688e21f595bd6b8fb585e43ace39a2b162 100644 (file)
@@ -959,6 +959,13 @@ struct duplicate_extents_to_file {
        __le64 ByteCount;  /* Bytes to be copied */
 } __packed;
 
+/*
+ * Maximum number of iovs we need for an ioctl request.
+ * [0] : struct smb2_ioctl_req
+ * [1] : in_data
+ */
+#define SMB2_IOCTL_IOV_SIZE 2
+
 struct smb2_ioctl_req {
        struct smb2_sync_hdr sync_hdr;
        __le16 StructureSize;   /* Must be 57 */
index 87733b27a65fef06c137e0782a04ab1151064ca6..3c32d0cfea69b0c7191336e5b38247de578ed63b 100644 (file)
@@ -144,6 +144,10 @@ extern int SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon,
                     u64 persistent_fid, u64 volatile_fid, u32 opcode,
                     bool is_fsctl, char *in_data, u32 indatalen,
                     char **out_data, u32 *plen /* returned data len */);
+extern int SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst,
+                          u64 persistent_fid, u64 volatile_fid, u32 opcode,
+                          bool is_fsctl, char *in_data, u32 indatalen);
+extern void SMB2_ioctl_free(struct smb_rqst *rqst);
 extern int SMB2_close(const unsigned int xid, struct cifs_tcon *tcon,
                      u64 persistent_file_id, u64 volatile_file_id);
 extern int SMB2_close_flags(const unsigned int xid, struct cifs_tcon *tcon,
@@ -223,6 +227,9 @@ extern int smb3_validate_negotiate(const unsigned int, struct cifs_tcon *);
 
 extern enum securityEnum smb2_select_sectype(struct TCP_Server_Info *,
                                        enum securityEnum);
+extern __u8 smb2_parse_lease_state(struct TCP_Server_Info *server,
+                                  struct smb2_create_rsp *rsp,
+                                  unsigned int *epoch, char *lease_key);
 extern int smb3_encryption_required(const struct cifs_tcon *tcon);
 extern int smb2_validate_iov(unsigned int offset, unsigned int buffer_length,
                             struct kvec *iov, unsigned int min_buf_size);
index 3d5f62150de42d0f6f2328bab1e6733f3b360690..447c0c6e4c640f818e3da2988befb847e3638180 100644 (file)
@@ -30,9 +30,9 @@
  */
 
 #define STATUS_SEVERITY_SUCCESS __constant_cpu_to_le32(0x0000)
-#define STATUS_SEVERITY_INFORMATIONAL __constanst_cpu_to_le32(0x0001)
-#define STATUS_SEVERITY_WARNING __constanst_cpu_to_le32(0x0002)
-#define STATUS_SEVERITY_ERROR __constanst_cpu_to_le32(0x0003)
+#define STATUS_SEVERITY_INFORMATIONAL cpu_to_le32(0x0001)
+#define STATUS_SEVERITY_WARNING cpu_to_le32(0x0002)
+#define STATUS_SEVERITY_ERROR cpu_to_le32(0x0003)
 
 struct ntstatus {
        /* Facility is the high 12 bits of the following field */
index d8b049afa6062f21bde5f2de7ebf40347da5081d..fa226de48ef38c0c0696aca767c69cc2ac8dbdd8 100644 (file)
@@ -59,6 +59,8 @@ DEFINE_EVENT(smb3_rw_err_class, smb3_##name,    \
 DEFINE_SMB3_RW_ERR_EVENT(write_err);
 DEFINE_SMB3_RW_ERR_EVENT(read_err);
 DEFINE_SMB3_RW_ERR_EVENT(query_dir_err);
+DEFINE_SMB3_RW_ERR_EVENT(zero_err);
+DEFINE_SMB3_RW_ERR_EVENT(falloc_err);
 
 
 /* For logging successful read or write */
@@ -104,9 +106,13 @@ DEFINE_EVENT(smb3_rw_done_class, smb3_##name,   \
 DEFINE_SMB3_RW_DONE_EVENT(write_enter);
 DEFINE_SMB3_RW_DONE_EVENT(read_enter);
 DEFINE_SMB3_RW_DONE_EVENT(query_dir_enter);
+DEFINE_SMB3_RW_DONE_EVENT(zero_enter);
+DEFINE_SMB3_RW_DONE_EVENT(falloc_enter);
 DEFINE_SMB3_RW_DONE_EVENT(write_done);
 DEFINE_SMB3_RW_DONE_EVENT(read_done);
 DEFINE_SMB3_RW_DONE_EVENT(query_dir_done);
+DEFINE_SMB3_RW_DONE_EVENT(zero_done);
+DEFINE_SMB3_RW_DONE_EVENT(falloc_done);
 
 /*
  * For handle based calls other than read and write, and get/set info
@@ -242,6 +248,123 @@ DEFINE_SMB3_INF_ERR_EVENT(query_info_err);
 DEFINE_SMB3_INF_ERR_EVENT(set_info_err);
 DEFINE_SMB3_INF_ERR_EVENT(fsctl_err);
 
+DECLARE_EVENT_CLASS(smb3_inf_compound_enter_class,
+       TP_PROTO(unsigned int xid,
+               __u32   tid,
+               __u64   sesid,
+               const char *full_path),
+       TP_ARGS(xid, tid, sesid, full_path),
+       TP_STRUCT__entry(
+               __field(unsigned int, xid)
+               __field(__u32, tid)
+               __field(__u64, sesid)
+               __string(path, full_path)
+       ),
+       TP_fast_assign(
+               __entry->xid = xid;
+               __entry->tid = tid;
+               __entry->sesid = sesid;
+               __assign_str(path, full_path);
+       ),
+       TP_printk("xid=%u sid=0x%llx tid=0x%x path=%s",
+               __entry->xid, __entry->sesid, __entry->tid,
+               __get_str(path))
+)
+
+#define DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(name)     \
+DEFINE_EVENT(smb3_inf_compound_enter_class, smb3_##name,    \
+       TP_PROTO(unsigned int xid,              \
+               __u32   tid,                    \
+               __u64   sesid,                  \
+               const char *full_path),         \
+       TP_ARGS(xid, tid, sesid, full_path))
+
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(query_info_compound_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(hardlink_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(rename_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(rmdir_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(set_eof_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(set_info_compound_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(delete_enter);
+DEFINE_SMB3_INF_COMPOUND_ENTER_EVENT(mkdir_enter);
+
+
+DECLARE_EVENT_CLASS(smb3_inf_compound_done_class,
+       TP_PROTO(unsigned int xid,
+               __u32   tid,
+               __u64   sesid),
+       TP_ARGS(xid, tid, sesid),
+       TP_STRUCT__entry(
+               __field(unsigned int, xid)
+               __field(__u32, tid)
+               __field(__u64, sesid)
+       ),
+       TP_fast_assign(
+               __entry->xid = xid;
+               __entry->tid = tid;
+               __entry->sesid = sesid;
+       ),
+       TP_printk("xid=%u sid=0x%llx tid=0x%x",
+               __entry->xid, __entry->sesid, __entry->tid)
+)
+
+#define DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(name)     \
+DEFINE_EVENT(smb3_inf_compound_done_class, smb3_##name,    \
+       TP_PROTO(unsigned int xid,              \
+               __u32   tid,                    \
+               __u64   sesid),                 \
+       TP_ARGS(xid, tid, sesid))
+
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(query_info_compound_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(hardlink_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(rename_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(rmdir_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(set_eof_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(set_info_compound_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(delete_done);
+DEFINE_SMB3_INF_COMPOUND_DONE_EVENT(mkdir_done);
+
+
+DECLARE_EVENT_CLASS(smb3_inf_compound_err_class,
+       TP_PROTO(unsigned int xid,
+               __u32   tid,
+               __u64   sesid,
+               int     rc),
+       TP_ARGS(xid, tid, sesid, rc),
+       TP_STRUCT__entry(
+               __field(unsigned int, xid)
+               __field(__u32, tid)
+               __field(__u64, sesid)
+               __field(int, rc)
+       ),
+       TP_fast_assign(
+               __entry->xid = xid;
+               __entry->tid = tid;
+               __entry->sesid = sesid;
+               __entry->rc = rc;
+       ),
+       TP_printk("xid=%u sid=0x%llx tid=0x%x rc=%d",
+               __entry->xid, __entry->sesid, __entry->tid,
+               __entry->rc)
+)
+
+#define DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(name)     \
+DEFINE_EVENT(smb3_inf_compound_err_class, smb3_##name,    \
+       TP_PROTO(unsigned int xid,              \
+               __u32   tid,                    \
+               __u64   sesid,                  \
+               int rc),                        \
+       TP_ARGS(xid, tid, sesid, rc))
+
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(query_info_compound_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(hardlink_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(rename_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(rmdir_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(set_eof_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(set_info_compound_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(mkdir_err);
+DEFINE_SMB3_INF_COMPOUND_ERR_EVENT(delete_err);
+
 /*
  * For logging SMB3 Status code and Command for responses which return errors
  */
@@ -713,6 +836,7 @@ DEFINE_EVENT(smb3_credit_class, smb3_##name,  \
        TP_ARGS(currmid, hostname, credits))
 
 DEFINE_SMB3_CREDIT_EVENT(reconnect_with_invalid_credits);
+DEFINE_SMB3_CREDIT_EVENT(credit_timeout);
 
 #endif /* _CIFS_TRACE_H */
 
index 7ce8a585abd620a847c325e0c310ab5669ed3e0d..1de8e996e566fd0bcc5642dcaba7bd88fed191ad 100644 (file)
@@ -486,15 +486,31 @@ smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
 }
 
 static int
-wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
-                     int *credits, unsigned int *instance)
+wait_for_free_credits(struct TCP_Server_Info *server, const int num_credits,
+                     const int timeout, const int flags,
+                     unsigned int *instance)
 {
        int rc;
+       int *credits;
+       int optype;
+       long int t;
+
+       if (timeout < 0)
+               t = MAX_JIFFY_OFFSET;
+       else
+               t = msecs_to_jiffies(timeout);
+
+       optype = flags & CIFS_OP_MASK;
 
        *instance = 0;
 
+       credits = server->ops->get_credits_field(server, optype);
+       /* Since an echo is already inflight, no need to wait to send another */
+       if (*credits <= 0 && optype == CIFS_ECHO_OP)
+               return -EAGAIN;
+
        spin_lock(&server->req_lock);
-       if (timeout == CIFS_ASYNC_OP) {
+       if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP) {
                /* oplock breaks must not be held up */
                server->in_flight++;
                *credits -= 1;
@@ -504,14 +520,21 @@ wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
        }
 
        while (1) {
-               if (*credits <= 0) {
+               if (*credits < num_credits) {
                        spin_unlock(&server->req_lock);
                        cifs_num_waiters_inc(server);
-                       rc = wait_event_killable(server->request_q,
-                                                has_credits(server, credits));
+                       rc = wait_event_killable_timeout(server->request_q,
+                               has_credits(server, credits, num_credits), t);
                        cifs_num_waiters_dec(server);
-                       if (rc)
-                               return rc;
+                       if (!rc) {
+                               trace_smb3_credit_timeout(server->CurrentMid,
+                                       server->hostname, num_credits);
+                               cifs_dbg(VFS, "wait timed out after %d ms\n",
+                                        timeout);
+                               return -ENOTSUPP;
+                       }
+                       if (rc == -ERESTARTSYS)
+                               return -ERESTARTSYS;
                        spin_lock(&server->req_lock);
                } else {
                        if (server->tcpStatus == CifsExiting) {
@@ -519,15 +542,53 @@ wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
                                return -ENOENT;
                        }
 
+                       /*
+                        * For normal commands, reserve the last MAX_COMPOUND
+                        * credits to compound requests.
+                        * Otherwise these compounds could be permanently
+                        * starved for credits by single-credit requests.
+                        *
+                        * To prevent spinning CPU, block this thread until
+                        * there are >MAX_COMPOUND credits available.
+                        * But only do this is we already have a lot of
+                        * credits in flight to avoid triggering this check
+                        * for servers that are slow to hand out credits on
+                        * new sessions.
+                        */
+                       if (!optype && num_credits == 1 &&
+                           server->in_flight > 2 * MAX_COMPOUND &&
+                           *credits <= MAX_COMPOUND) {
+                               spin_unlock(&server->req_lock);
+                               cifs_num_waiters_inc(server);
+                               rc = wait_event_killable_timeout(
+                                       server->request_q,
+                                       has_credits(server, credits,
+                                                   MAX_COMPOUND + 1),
+                                       t);
+                               cifs_num_waiters_dec(server);
+                               if (!rc) {
+                                       trace_smb3_credit_timeout(
+                                               server->CurrentMid,
+                                               server->hostname, num_credits);
+                                       cifs_dbg(VFS, "wait timed out after %d ms\n",
+                                                timeout);
+                                       return -ENOTSUPP;
+                               }
+                               if (rc == -ERESTARTSYS)
+                                       return -ERESTARTSYS;
+                               spin_lock(&server->req_lock);
+                               continue;
+                       }
+
                        /*
                         * Can not count locking commands against total
                         * as they are allowed to block on server.
                         */
 
                        /* update # of requests on the wire to server */
-                       if (timeout != CIFS_BLOCKING_OP) {
-                               *credits -= 1;
-                               server->in_flight++;
+                       if ((flags & CIFS_TIMEOUT_MASK) != CIFS_BLOCKING_OP) {
+                               *credits -= num_credits;
+                               server->in_flight += num_credits;
                                *instance = server->reconnect_instance;
                        }
                        spin_unlock(&server->req_lock);
@@ -538,16 +599,36 @@ wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
 }
 
 static int
-wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
-                     const int optype, unsigned int *instance)
+wait_for_free_request(struct TCP_Server_Info *server, const int flags,
+                     unsigned int *instance)
 {
-       int *val;
+       return wait_for_free_credits(server, 1, -1, flags,
+                                    instance);
+}
 
-       val = server->ops->get_credits_field(server, optype);
-       /* Since an echo is already inflight, no need to wait to send another */
-       if (*val <= 0 && optype == CIFS_ECHO_OP)
-               return -EAGAIN;
-       return wait_for_free_credits(server, timeout, val, instance);
+static int
+wait_for_compound_request(struct TCP_Server_Info *server, int num,
+                         const int flags, unsigned int *instance)
+{
+       int *credits;
+
+       credits = server->ops->get_credits_field(server, flags & CIFS_OP_MASK);
+
+       spin_lock(&server->req_lock);
+       if (*credits < num) {
+               /*
+                * Return immediately if not too many requests in flight since
+                * we will likely be stuck on waiting for credits.
+                */
+               if (server->in_flight < num - *credits) {
+                       spin_unlock(&server->req_lock);
+                       return -ENOTSUPP;
+               }
+       }
+       spin_unlock(&server->req_lock);
+
+       return wait_for_free_credits(server, num, 60000, flags,
+                                    instance);
 }
 
 int
@@ -646,16 +727,16 @@ cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
                mid_handle_t *handle, void *cbdata, const int flags,
                const struct cifs_credits *exist_credits)
 {
-       int rc, timeout, optype;
+       int rc;
        struct mid_q_entry *mid;
        struct cifs_credits credits = { .value = 0, .instance = 0 };
        unsigned int instance;
+       int optype;
 
-       timeout = flags & CIFS_TIMEOUT_MASK;
        optype = flags & CIFS_OP_MASK;
 
        if ((flags & CIFS_HAS_CREDITS) == 0) {
-               rc = wait_for_free_request(server, timeout, optype, &instance);
+               rc = wait_for_free_request(server, flags, &instance);
                if (rc)
                        return rc;
                credits.value = 1;
@@ -871,18 +952,15 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
                   const int flags, const int num_rqst, struct smb_rqst *rqst,
                   int *resp_buf_type, struct kvec *resp_iov)
 {
-       int i, j, rc = 0;
-       int timeout, optype;
+       int i, j, optype, rc = 0;
        struct mid_q_entry *midQ[MAX_COMPOUND];
        bool cancelled_mid[MAX_COMPOUND] = {false};
        struct cifs_credits credits[MAX_COMPOUND] = {
                { .value = 0, .instance = 0 }
        };
        unsigned int instance;
-       unsigned int first_instance = 0;
        char *buf;
 
-       timeout = flags & CIFS_TIMEOUT_MASK;
        optype = flags & CIFS_OP_MASK;
 
        for (i = 0; i < num_rqst; i++)
@@ -896,81 +974,24 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
        if (ses->server->tcpStatus == CifsExiting)
                return -ENOENT;
 
-       spin_lock(&ses->server->req_lock);
-       if (ses->server->credits < num_rqst) {
-               /*
-                * Return immediately if not too many requests in flight since
-                * we will likely be stuck on waiting for credits.
-                */
-               if (ses->server->in_flight < num_rqst - ses->server->credits) {
-                       spin_unlock(&ses->server->req_lock);
-                       return -ENOTSUPP;
-               }
-       } else {
-               /* enough credits to send the whole compounded request */
-               ses->server->credits -= num_rqst;
-               ses->server->in_flight += num_rqst;
-               first_instance = ses->server->reconnect_instance;
-       }
-       spin_unlock(&ses->server->req_lock);
-
-       if (first_instance) {
-               cifs_dbg(FYI, "Acquired %d credits at once\n", num_rqst);
-               for (i = 0; i < num_rqst; i++) {
-                       credits[i].value = 1;
-                       credits[i].instance = first_instance;
-               }
-               goto setup_rqsts;
-       }
-
        /*
-        * There are not enough credits to send the whole compound request but
-        * there are requests in flight that may bring credits from the server.
+        * Wait for all the requests to become available.
         * This approach still leaves the possibility to be stuck waiting for
         * credits if the server doesn't grant credits to the outstanding
-        * requests. This should be fixed by returning immediately and letting
-        * a caller fallback to sequential commands instead of compounding.
-        * Ensure we obtain 1 credit per request in the compound chain.
+        * requests and if the client is completely idle, not generating any
+        * other requests.
+        * This can be handled by the eventual session reconnect.
         */
-       for (i = 0; i < num_rqst; i++) {
-               rc = wait_for_free_request(ses->server, timeout, optype,
-                                          &instance);
-
-               if (rc == 0) {
-                       credits[i].value = 1;
-                       credits[i].instance = instance;
-                       /*
-                        * All parts of the compound chain must get credits from
-                        * the same session, otherwise we may end up using more
-                        * credits than the server granted. If there were
-                        * reconnects in between, return -EAGAIN and let callers
-                        * handle it.
-                        */
-                       if (i == 0)
-                               first_instance = instance;
-                       else if (first_instance != instance) {
-                               i++;
-                               rc = -EAGAIN;
-                       }
-               }
+       rc = wait_for_compound_request(ses->server, num_rqst, flags,
+                                      &instance);
+       if (rc)
+               return rc;
 
-               if (rc) {
-                       /*
-                        * We haven't sent an SMB packet to the server yet but
-                        * we already obtained credits for i requests in the
-                        * compound chain - need to return those credits back
-                        * for future use. Note that we need to call add_credits
-                        * multiple times to match the way we obtained credits
-                        * in the first place and to account for in flight
-                        * requests correctly.
-                        */
-                       for (j = 0; j < i; j++)
-                               add_credits(ses->server, &credits[j], optype);
-                       return rc;
-               }
+       for (i = 0; i < num_rqst; i++) {
+               credits[i].value = 1;
+               credits[i].instance = instance;
        }
 
-setup_rqsts:
        /*
         * Make sure that we sign in the same order that we send on this socket
         * and avoid races inside tcp sendmsg code that could cause corruption
@@ -981,14 +1002,12 @@ setup_rqsts:
 
        /*
         * All the parts of the compound chain belong obtained credits from the
-        * same session (see the appropriate checks above). In the same time
-        * there might be reconnects after those checks but before we acquired
-        * the srv_mutex. We can not use credits obtained from the previous
+        * same session. We can not use credits obtained from the previous
         * session to send this request. Check if there were reconnects after
         * we obtained credits and return -EAGAIN in such cases to let callers
         * handle it.
         */
-       if (first_instance != ses->server->reconnect_instance) {
+       if (instance != ses->server->reconnect_instance) {
                mutex_unlock(&ses->server->srv_mutex);
                for (j = 0; j < num_rqst; j++)
                        add_credits(ses->server, &credits[j], optype);
@@ -1057,7 +1076,7 @@ setup_rqsts:
                smb311_update_preauth_hash(ses, rqst[0].rq_iov,
                                           rqst[0].rq_nvec);
 
-       if (timeout == CIFS_ASYNC_OP)
+       if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP)
                goto out;
 
        for (i = 0; i < num_rqst; i++) {
@@ -1194,7 +1213,7 @@ SendReceive2(const unsigned int xid, struct cifs_ses *ses,
 int
 SendReceive(const unsigned int xid, struct cifs_ses *ses,
            struct smb_hdr *in_buf, struct smb_hdr *out_buf,
-           int *pbytes_returned, const int timeout)
+           int *pbytes_returned, const int flags)
 {
        int rc = 0;
        struct mid_q_entry *midQ;
@@ -1225,7 +1244,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
                return -EIO;
        }
 
-       rc = wait_for_free_request(ses->server, timeout, 0, &credits.instance);
+       rc = wait_for_free_request(ses->server, flags, &credits.instance);
        if (rc)
                return rc;
 
@@ -1264,7 +1283,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
        if (rc < 0)
                goto out;
 
-       if (timeout == CIFS_ASYNC_OP)
+       if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP)
                goto out;
 
        rc = wait_for_response(ses->server, midQ);
@@ -1367,8 +1386,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
                return -EIO;
        }
 
-       rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0,
-                                  &instance);
+       rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, &instance);
        if (rc)
                return rc;