Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/cifs/link.c |
| 3 | * |
| 4 | * Copyright (C) International Business Machines Corp., 2002,2003 |
| 5 | * Author(s): Steve French (sfrench@us.ibm.com) |
| 6 | * |
| 7 | * This library is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU Lesser General Public License as published |
| 9 | * by the Free Software Foundation; either version 2.1 of the License, or |
| 10 | * (at your option) any later version. |
| 11 | * |
| 12 | * This library is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| 15 | * the GNU Lesser General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU Lesser General Public License |
| 18 | * along with this library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 20 | */ |
| 21 | #include <linux/fs.h> |
| 22 | #include <linux/stat.h> |
| 23 | #include <linux/namei.h> |
| 24 | #include "cifsfs.h" |
| 25 | #include "cifspdu.h" |
| 26 | #include "cifsglob.h" |
| 27 | #include "cifsproto.h" |
| 28 | #include "cifs_debug.h" |
| 29 | #include "cifs_fs_sb.h" |
| 30 | |
| 31 | int |
| 32 | cifs_hardlink(struct dentry *old_file, struct inode *inode, |
| 33 | struct dentry *direntry) |
| 34 | { |
| 35 | int rc = -EACCES; |
| 36 | int xid; |
| 37 | char *fromName = NULL; |
| 38 | char *toName = NULL; |
| 39 | struct cifs_sb_info *cifs_sb_target; |
| 40 | struct cifsTconInfo *pTcon; |
| 41 | struct cifsInodeInfo *cifsInode; |
| 42 | |
| 43 | xid = GetXid(); |
| 44 | |
| 45 | cifs_sb_target = CIFS_SB(inode->i_sb); |
| 46 | pTcon = cifs_sb_target->tcon; |
| 47 | |
| 48 | /* No need to check for cross device links since server will do that |
| 49 | BB note DFS case in future though (when we may have to check) */ |
| 50 | |
Steve French | 7f57356 | 2005-08-30 11:32:14 -0700 | [diff] [blame] | 51 | fromName = build_path_from_dentry(old_file); |
| 52 | toName = build_path_from_dentry(direntry); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 53 | if ((fromName == NULL) || (toName == NULL)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | rc = -ENOMEM; |
| 55 | goto cifs_hl_exit; |
| 56 | } |
| 57 | |
| 58 | if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX) |
| 59 | rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 60 | cifs_sb_target->local_nls, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 61 | cifs_sb_target->mnt_cifs_flags & |
| 62 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | else { |
| 64 | rc = CIFSCreateHardLink(xid, pTcon, fromName, toName, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 65 | cifs_sb_target->local_nls, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 66 | cifs_sb_target->mnt_cifs_flags & |
| 67 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 68 | if ((rc == -EIO) || (rc == -EINVAL)) |
| 69 | rc = -EOPNOTSUPP; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | } |
| 71 | |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 72 | d_drop(direntry); /* force new lookup from server of target */ |
| 73 | |
| 74 | /* if source file is cached (oplocked) revalidate will not go to server |
| 75 | until the file is closed or oplock broken so update nlinks locally */ |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 76 | if (old_file->d_inode) { |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 77 | cifsInode = CIFS_I(old_file->d_inode); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 78 | if (rc == 0) { |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 79 | old_file->d_inode->i_nlink++; |
Steve French | 1b2b212 | 2007-02-17 04:30:54 +0000 | [diff] [blame] | 80 | /* BB should we make this contingent on superblock flag NOATIME? */ |
| 81 | /* old_file->d_inode->i_ctime = CURRENT_TIME;*/ |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 82 | /* parent dir timestamps will update from srv |
| 83 | within a second, would it really be worth it |
| 84 | to set the parent dir cifs inode time to zero |
| 85 | to force revalidate (faster) for it too? */ |
| 86 | } |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 87 | /* if not oplocked will force revalidate to get info |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 88 | on source file from srv */ |
| 89 | cifsInode->time = 0; |
| 90 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 91 | /* Will update parent dir timestamps from srv within a second. |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 92 | Would it really be worth it to set the parent dir (cifs |
| 93 | inode) time field to zero to force revalidate on parent |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 94 | directory faster ie |
Steve French | 31ec35d | 2006-11-16 20:54:20 +0000 | [diff] [blame] | 95 | CIFS_I(inode)->time = 0; */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | |
| 98 | cifs_hl_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 99 | kfree(fromName); |
| 100 | kfree(toName); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | FreeXid(xid); |
| 102 | return rc; |
| 103 | } |
| 104 | |
Linus Torvalds | cc314ee | 2005-08-19 18:02:56 -0700 | [diff] [blame] | 105 | void * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | cifs_follow_link(struct dentry *direntry, struct nameidata *nd) |
| 107 | { |
| 108 | struct inode *inode = direntry->d_inode; |
| 109 | int rc = -EACCES; |
| 110 | int xid; |
| 111 | char *full_path = NULL; |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 112 | char *target_path = ERR_PTR(-ENOMEM); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | struct cifs_sb_info *cifs_sb; |
| 114 | struct cifsTconInfo *pTcon; |
| 115 | |
| 116 | xid = GetXid(); |
| 117 | |
Steve French | 7f57356 | 2005-08-30 11:32:14 -0700 | [diff] [blame] | 118 | full_path = build_path_from_dentry(direntry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | |
| 120 | if (!full_path) |
| 121 | goto out_no_free; |
| 122 | |
| 123 | cFYI(1, ("Full path: %s inode = 0x%p", full_path, inode)); |
Steve French | 7f57356 | 2005-08-30 11:32:14 -0700 | [diff] [blame] | 124 | cifs_sb = CIFS_SB(inode->i_sb); |
| 125 | pTcon = cifs_sb->tcon; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | target_path = kmalloc(PATH_MAX, GFP_KERNEL); |
| 127 | if (!target_path) { |
| 128 | target_path = ERR_PTR(-ENOMEM); |
| 129 | goto out; |
| 130 | } |
| 131 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 132 | /* BB add read reparse point symlink code and Unix extensions |
| 133 | symlink code here BB */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | if (pTcon->ses->capabilities & CAP_UNIX) |
| 135 | rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path, |
| 136 | target_path, |
| 137 | PATH_MAX-1, |
| 138 | cifs_sb->local_nls); |
| 139 | else { |
| 140 | /* rc = CIFSSMBQueryReparseLinkInfo */ |
| 141 | /* BB Add code to Query ReparsePoint info */ |
| 142 | /* BB Add MAC style xsymlink check here if enabled */ |
| 143 | } |
| 144 | |
| 145 | if (rc == 0) { |
| 146 | |
| 147 | /* BB Add special case check for Samba DFS symlinks */ |
| 148 | |
| 149 | target_path[PATH_MAX-1] = 0; |
| 150 | } else { |
| 151 | kfree(target_path); |
| 152 | target_path = ERR_PTR(rc); |
| 153 | } |
| 154 | |
| 155 | out: |
| 156 | kfree(full_path); |
| 157 | out_no_free: |
| 158 | FreeXid(xid); |
| 159 | nd_set_link(nd, target_path); |
Linus Torvalds | cc314ee | 2005-08-19 18:02:56 -0700 | [diff] [blame] | 160 | return NULL; /* No cookie */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | int |
| 164 | cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname) |
| 165 | { |
| 166 | int rc = -EOPNOTSUPP; |
| 167 | int xid; |
| 168 | struct cifs_sb_info *cifs_sb; |
| 169 | struct cifsTconInfo *pTcon; |
| 170 | char *full_path = NULL; |
| 171 | struct inode *newinode = NULL; |
| 172 | |
| 173 | xid = GetXid(); |
| 174 | |
| 175 | cifs_sb = CIFS_SB(inode->i_sb); |
| 176 | pTcon = cifs_sb->tcon; |
| 177 | |
Steve French | 7f57356 | 2005-08-30 11:32:14 -0700 | [diff] [blame] | 178 | full_path = build_path_from_dentry(direntry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 180 | if (full_path == NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | FreeXid(xid); |
| 182 | return -ENOMEM; |
| 183 | } |
| 184 | |
Steve French | 26a21b9 | 2006-05-31 18:05:34 +0000 | [diff] [blame] | 185 | cFYI(1, ("Full path: %s", full_path)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | cFYI(1, ("symname is %s", symname)); |
| 187 | |
| 188 | /* BB what if DFS and this volume is on different share? BB */ |
| 189 | if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) |
| 190 | rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname, |
| 191 | cifs_sb->local_nls); |
| 192 | /* else |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 193 | rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName, |
| 194 | cifs_sb_target->local_nls); */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | |
| 196 | if (rc == 0) { |
| 197 | if (pTcon->ses->capabilities & CAP_UNIX) |
| 198 | rc = cifs_get_inode_info_unix(&newinode, full_path, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 199 | inode->i_sb, xid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | else |
| 201 | rc = cifs_get_inode_info(&newinode, full_path, NULL, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 202 | inode->i_sb, xid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | |
| 204 | if (rc != 0) { |
Steve French | 26a21b9 | 2006-05-31 18:05:34 +0000 | [diff] [blame] | 205 | cFYI(1, ("Create symlink ok, getinodeinfo fail rc = %d", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | rc)); |
| 207 | } else { |
Steve French | b92327f | 2005-08-22 20:09:43 -0700 | [diff] [blame] | 208 | if (pTcon->nocase) |
| 209 | direntry->d_op = &cifs_ci_dentry_ops; |
| 210 | else |
| 211 | direntry->d_op = &cifs_dentry_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | d_instantiate(direntry, newinode); |
| 213 | } |
| 214 | } |
| 215 | |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 216 | kfree(full_path); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | FreeXid(xid); |
| 218 | return rc; |
| 219 | } |
| 220 | |
| 221 | int |
| 222 | cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen) |
| 223 | { |
| 224 | struct inode *inode = direntry->d_inode; |
| 225 | int rc = -EACCES; |
| 226 | int xid; |
| 227 | int oplock = FALSE; |
| 228 | struct cifs_sb_info *cifs_sb; |
| 229 | struct cifsTconInfo *pTcon; |
| 230 | char *full_path = NULL; |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 231 | char *tmp_path = NULL; |
| 232 | char *tmpbuffer; |
| 233 | unsigned char *referrals = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | int num_referrals = 0; |
| 235 | int len; |
| 236 | __u16 fid; |
| 237 | |
| 238 | xid = GetXid(); |
| 239 | cifs_sb = CIFS_SB(inode->i_sb); |
| 240 | pTcon = cifs_sb->tcon; |
| 241 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 242 | /* BB would it be safe against deadlock to grab this sem |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | even though rename itself grabs the sem and calls lookup? */ |
Arjan van de Ven | a11f3a0 | 2006-03-23 03:00:33 -0800 | [diff] [blame] | 244 | /* mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/ |
Steve French | 7f57356 | 2005-08-30 11:32:14 -0700 | [diff] [blame] | 245 | full_path = build_path_from_dentry(direntry); |
Arjan van de Ven | a11f3a0 | 2006-03-23 03:00:33 -0800 | [diff] [blame] | 246 | /* mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 248 | if (full_path == NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | FreeXid(xid); |
| 250 | return -ENOMEM; |
| 251 | } |
| 252 | |
| 253 | cFYI(1, |
| 254 | ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d", |
| 255 | full_path, inode, pBuffer, buflen)); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 256 | if (buflen > PATH_MAX) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | len = PATH_MAX; |
| 258 | else |
| 259 | len = buflen; |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 260 | tmpbuffer = kmalloc(len, GFP_KERNEL); |
| 261 | if (tmpbuffer == NULL) { |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 262 | kfree(full_path); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | FreeXid(xid); |
| 264 | return -ENOMEM; |
| 265 | } |
| 266 | |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 267 | /* BB add read reparse point symlink code and |
| 268 | Unix extensions symlink code here BB */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) |
| 270 | rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path, |
| 271 | tmpbuffer, |
| 272 | len - 1, |
| 273 | cifs_sb->local_nls); |
Steve French | 1bd5bbc | 2006-09-28 03:35:57 +0000 | [diff] [blame] | 274 | else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) { |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 275 | cERROR(1, ("SFU style symlinks not implemented yet")); |
Steve French | 1bd5bbc | 2006-09-28 03:35:57 +0000 | [diff] [blame] | 276 | /* add open and read as in fs/cifs/inode.c */ |
| 277 | |
| 278 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 280 | OPEN_REPARSE_POINT, &fid, &oplock, NULL, |
| 281 | cifs_sb->local_nls, |
| 282 | cifs_sb->mnt_cifs_flags & |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 283 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 284 | if (!rc) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path, |
| 286 | tmpbuffer, |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 287 | len - 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | fid, |
| 289 | cifs_sb->local_nls); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 290 | if (CIFSSMBClose(xid, pTcon, fid)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | cFYI(1,("Error closing junction point (open for ioctl)")); |
| 292 | } |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 293 | if (rc == -EIO) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | /* Query if DFS Junction */ |
| 295 | tmp_path = |
| 296 | kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1, |
| 297 | GFP_KERNEL); |
| 298 | if (tmp_path) { |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 299 | strncpy(tmp_path, pTcon->treeName, |
| 300 | MAX_TREE_SIZE); |
| 301 | strncat(tmp_path, full_path, |
| 302 | MAX_PATHCONF); |
| 303 | rc = get_dfs_path(xid, pTcon->ses, |
| 304 | tmp_path, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 305 | cifs_sb->local_nls, |
| 306 | &num_referrals, &referrals, |
| 307 | cifs_sb->mnt_cifs_flags & |
| 308 | CIFS_MOUNT_MAP_SPECIAL_CHR); |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 309 | cFYI(1, ("Get DFS for %s rc = %d ", |
| 310 | tmp_path, rc)); |
| 311 | if ((num_referrals == 0) && (rc == 0)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | rc = -EACCES; |
| 313 | else { |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 314 | cFYI(1, ("num referral: %d", |
| 315 | num_referrals)); |
| 316 | if (referrals) { |
| 317 | cFYI(1,("referral string: %s", referrals)); |
| 318 | strncpy(tmpbuffer, referrals, len-1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | } |
| 320 | } |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 321 | kfree(referrals); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | kfree(tmp_path); |
| 323 | } |
Steve French | fb8c4b1 | 2007-07-10 01:16:18 +0000 | [diff] [blame^] | 324 | /* BB add code like else decode referrals |
| 325 | then memcpy to tmpbuffer and free referrals |
| 326 | string array BB */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | } |
| 328 | } |
| 329 | } |
| 330 | /* BB Anything else to do to handle recursive links? */ |
| 331 | /* BB Should we be using page ops here? */ |
| 332 | |
| 333 | /* BB null terminate returned string in pBuffer? BB */ |
| 334 | if (rc == 0) { |
| 335 | rc = vfs_readlink(direntry, pBuffer, len, tmpbuffer); |
| 336 | cFYI(1, |
| 337 | ("vfs_readlink called from cifs_readlink returned %d", |
| 338 | rc)); |
| 339 | } |
| 340 | |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 341 | kfree(tmpbuffer); |
| 342 | kfree(full_path); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | FreeXid(xid); |
| 344 | return rc; |
| 345 | } |
| 346 | |
Linus Torvalds | cc314ee | 2005-08-19 18:02:56 -0700 | [diff] [blame] | 347 | void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | { |
| 349 | char *p = nd_get_link(nd); |
| 350 | if (!IS_ERR(p)) |
| 351 | kfree(p); |
| 352 | } |