Patched in Tegra support.

1 files changed, 58 insertions, 81 deletions

diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 51dc2fb6e85..db3f18cdf02 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -56,14 +56,14 @@ symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
         md5 = crypto_alloc_shash("md5", 0, 0);
         if (IS_ERR(md5)) {
                 rc = PTR_ERR(md5);
-                cERROR(1, "%s: Crypto md5 allocation error %d", __func__, rc);
+                cERROR(1, "%s: Crypto md5 allocation error %d\n", __func__, rc);
                 return rc;
         }
         size = sizeof(struct shash_desc) + crypto_shash_descsize(md5);
         sdescmd5 = kmalloc(size, GFP_KERNEL);
         if (!sdescmd5) {
                 rc = -ENOMEM;
-                cERROR(1, "%s: Memory allocation failure", __func__);
+                cERROR(1, "%s: Memory allocation failure\n", __func__);
                 goto symlink_hash_err;
         }
         sdescmd5->shash.tfm = md5;
@@ -71,17 +71,17 @@ symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
 
         rc = crypto_shash_init(&sdescmd5->shash);
         if (rc) {
-                cERROR(1, "%s: Could not init md5 shash", __func__);
+                cERROR(1, "%s: Could not init md5 shash\n", __func__);
                 goto symlink_hash_err;
         }
         rc = crypto_shash_update(&sdescmd5->shash, link_str, link_len);
         if (rc) {
-                cERROR(1, "%s: Could not update iwth link_str", __func__);
+                cERROR(1, "%s: Could not update iwth link_str\n", __func__);
                 goto symlink_hash_err;
         }
         rc = crypto_shash_final(&sdescmd5->shash, md5_hash);
         if (rc)
-                cERROR(1, "%s: Could not generate md5 hash", __func__);
+                cERROR(1, "%s: Could not generate md5 hash\n", __func__);
 
 symlink_hash_err:
         crypto_free_shash(md5);
@@ -115,7 +115,7 @@ CIFSParseMFSymlink(const u8 *buf,
 
         rc = symlink_hash(link_len, link_str, md5_hash);
         if (rc) {
-                cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
+                cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
                 return rc;
         }
 
@@ -154,7 +154,7 @@ CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
 
         rc = symlink_hash(link_len, link_str, md5_hash);
         if (rc) {
-                cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
+                cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
                 return rc;
         }
 
@@ -181,22 +181,16 @@ CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
 }
 
 static int
-CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSCreateMFSymLink(const int xid, struct cifs_tcon *tcon,
                     const char *fromName, const char *toName,
-                    struct cifs_sb_info *cifs_sb)
+                    const struct nls_table *nls_codepage, int remap)
 {
         int rc;
         int oplock = 0;
-        int remap;
-        int create_options = CREATE_NOT_DIR;
         __u16 netfid = 0;
         u8 *buf;
         unsigned int bytes_written = 0;
         struct cifs_io_parms io_parms;
-        struct nls_table *nls_codepage;
-
-        nls_codepage = cifs_sb->local_nls;
-        remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
 
         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
         if (!buf)
@@ -208,11 +202,8 @@ CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
                 return rc;
         }
 
-        if (backup_cred(cifs_sb))
-                create_options |= CREATE_OPEN_BACKUP_INTENT;
-
         rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,
-                         create_options, &netfid, &oplock, NULL,
+                         CREATE_NOT_DIR, &netfid, &oplock, NULL,
                          nls_codepage, remap);
         if (rc != 0) {
                 kfree(buf);
@@ -238,7 +229,7 @@ CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
 }
 
 static int
-CIFSQueryMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
+CIFSQueryMFSymLink(const int xid, struct cifs_tcon *tcon,
                    const unsigned char *searchName, char **symlinkinfo,
                    const struct nls_table *nls_codepage, int remap)
 {
@@ -307,7 +298,7 @@ CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr)
 int
 CIFSCheckMFSymlink(struct cifs_fattr *fattr,
                    const unsigned char *path,
-                   struct cifs_sb_info *cifs_sb, unsigned int xid)
+                   struct cifs_sb_info *cifs_sb, int xid)
 {
         int rc;
         int oplock = 0;
@@ -390,88 +381,72 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
               struct dentry *direntry)
 {
         int rc = -EACCES;
-        unsigned int xid;
-        char *from_name = NULL;
-        char *to_name = NULL;
+        int xid;
+        char *fromName = NULL;
+        char *toName = NULL;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
-        struct TCP_Server_Info *server;
+        struct cifs_tcon *pTcon;
         struct cifsInodeInfo *cifsInode;
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink))
                 return PTR_ERR(tlink);
-        tcon = tlink_tcon(tlink);
+        pTcon = tlink_tcon(tlink);
 
-        xid = get_xid();
+        xid = GetXid();
 
-        from_name = build_path_from_dentry(old_file);
-        to_name = build_path_from_dentry(direntry);
-        if ((from_name == NULL) || (to_name == NULL)) {
+        fromName = build_path_from_dentry(old_file);
+        toName = build_path_from_dentry(direntry);
+        if ((fromName == NULL) || (toName == NULL)) {
                 rc = -ENOMEM;
                 goto cifs_hl_exit;
         }
 
-        if (tcon->unix_ext)
-                rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
+        if (pTcon->unix_ext)
+                rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
                                             cifs_sb->local_nls,
                                             cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
         else {
-                server = tcon->ses->server;
-                if (!server->ops->create_hardlink)
-                        return -ENOSYS;
-                rc = server->ops->create_hardlink(xid, tcon, from_name, to_name,
-                                                  cifs_sb);
+                rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
+                                        cifs_sb->local_nls,
+                                        cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
                 if ((rc == -EIO) || (rc == -EINVAL))
                         rc = -EOPNOTSUPP;
         }
 
         d_drop(direntry);       /* force new lookup from server of target */
 
-        /*
-         * if source file is cached (oplocked) revalidate will not go to server
-         * until the file is closed or oplock broken so update nlinks locally
-         */
+        /* if source file is cached (oplocked) revalidate will not go to server
+           until the file is closed or oplock broken so update nlinks locally */
         if (old_file->d_inode) {
                 cifsInode = CIFS_I(old_file->d_inode);
                 if (rc == 0) {
-                        spin_lock(&old_file->d_inode->i_lock);
-                        inc_nlink(old_file->d_inode);
-                        spin_unlock(&old_file->d_inode->i_lock);
-                        /*
-                         * BB should we make this contingent on superblock flag
-                         * NOATIME?
-                         */
-                        /* old_file->d_inode->i_ctime = CURRENT_TIME; */
-                        /*
-                         * parent dir timestamps will update from srv within a
-                         * second, would it really be worth it to set the parent
-                         * dir cifs inode time to zero to force revalidate
-                         * (faster) for it too?
-                         */
+                        old_file->d_inode->i_nlink++;
+/* BB should we make this contingent on superblock flag NOATIME? */
+/*                      old_file->d_inode->i_ctime = CURRENT_TIME;*/
+                        /* parent dir timestamps will update from srv
+                        within a second, would it really be worth it
+                        to set the parent dir cifs inode time to zero
+                        to force revalidate (faster) for it too? */
                 }
-                /*
-                 * if not oplocked will force revalidate to get info on source
-                 * file from srv
-                 */
+                /* if not oplocked will force revalidate to get info
+                   on source file from srv */
                 cifsInode->time = 0;
 
-                /*
-                 * Will update parent dir timestamps from srv within a second.
-                 * Would it really be worth it to set the parent dir (cifs
-                 * inode) time field to zero to force revalidate on parent
-                 * directory faster ie
-                 *
-                 * CIFS_I(inode)->time = 0;
-                 */
+                /* Will update parent dir timestamps from srv within a second.
+                   Would it really be worth it to set the parent dir (cifs
+                   inode) time field to zero to force revalidate on parent
+                   directory faster ie
+                        CIFS_I(inode)->time = 0;  */
         }
 
 cifs_hl_exit:
-        kfree(from_name);
-        kfree(to_name);
-        free_xid(xid);
+        kfree(fromName);
+        kfree(toName);
+        FreeXid(xid);
         cifs_put_tlink(tlink);
         return rc;
 }
@@ -481,14 +456,14 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 {
         struct inode *inode = direntry->d_inode;
         int rc = -ENOMEM;
-        unsigned int xid;
+        int xid;
         char *full_path = NULL;
         char *target_path = NULL;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink = NULL;
         struct cifs_tcon *tcon;
 
-        xid = get_xid();
+        xid = GetXid();
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
@@ -511,8 +486,8 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
          * but there doesn't seem to be any harm in allowing the client to
          * read them.
          */
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
-            !cap_unix(tcon->ses)) {
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
+            && !(tcon->ses->capabilities & CAP_UNIX)) {
                 rc = -EACCES;
                 goto out;
         }
@@ -534,7 +509,7 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
                                         cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 
-        if ((rc != 0) && cap_unix(tcon->ses))
+        if ((rc != 0) && (tcon->ses->capabilities & CAP_UNIX))
                 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
                                              cifs_sb->local_nls);
 
@@ -545,7 +520,7 @@ out:
                 target_path = ERR_PTR(rc);
         }
 
-        free_xid(xid);
+        FreeXid(xid);
         if (tlink)
                 cifs_put_tlink(tlink);
         nd_set_link(nd, target_path);
@@ -556,14 +531,14 @@ int
 cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 {
         int rc = -EOPNOTSUPP;
-        unsigned int xid;
+        int xid;
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
         struct cifs_tcon *pTcon;
         char *full_path = NULL;
         struct inode *newinode = NULL;
 
-        xid = get_xid();
+        xid = GetXid();
 
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
@@ -584,7 +559,9 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
         /* BB what if DFS and this volume is on different share? BB */
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
                 rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,
-                                        cifs_sb);
+                                         cifs_sb->local_nls,
+                                         cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
         else if (pTcon->unix_ext)
                 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
                                            cifs_sb->local_nls);
@@ -610,7 +587,7 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 symlink_exit:
         kfree(full_path);
         cifs_put_tlink(tlink);
-        free_xid(xid);
+        FreeXid(xid);
         return rc;
 }