link.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343
  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. int
  31. cifs_hardlink(struct dentry *old_file, struct inode *inode,
  32. struct dentry *direntry)
  33. {
  34. int rc = -EACCES;
  35. int xid;
  36. char *fromName = NULL;
  37. char *toName = NULL;
  38. struct cifs_sb_info *cifs_sb_target;
  39. struct cifsTconInfo *pTcon;
  40. struct cifsInodeInfo *cifsInode;
  41. xid = GetXid();
  42. cifs_sb_target = CIFS_SB(inode->i_sb);
  43. pTcon = cifs_sb_target->tcon;
  44. /* No need to check for cross device links since server will do that
  45. BB note DFS case in future though (when we may have to check) */
  46. fromName = build_path_from_dentry(old_file);
  47. toName = build_path_from_dentry(direntry);
  48. if((fromName == NULL) || (toName == NULL)) {
  49. rc = -ENOMEM;
  50. goto cifs_hl_exit;
  51. }
  52. if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)
  53. rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
  54. cifs_sb_target->local_nls,
  55. cifs_sb_target->mnt_cifs_flags &
  56. CIFS_MOUNT_MAP_SPECIAL_CHR);
  57. else {
  58. rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
  59. cifs_sb_target->local_nls,
  60. cifs_sb_target->mnt_cifs_flags &
  61. CIFS_MOUNT_MAP_SPECIAL_CHR);
  62. if((rc == -EIO) || (rc == -EINVAL))
  63. rc = -EOPNOTSUPP;
  64. }
  65. d_drop(direntry); /* force new lookup from server of target */
  66. /* if source file is cached (oplocked) revalidate will not go to server
  67. until the file is closed or oplock broken so update nlinks locally */
  68. if(old_file->d_inode) {
  69. cifsInode = CIFS_I(old_file->d_inode);
  70. if(rc == 0) {
  71. old_file->d_inode->i_nlink++;
  72. /* BB should we make this contingent on superblock flag NOATIME? */
  73. /* old_file->d_inode->i_ctime = CURRENT_TIME;*/
  74. /* parent dir timestamps will update from srv
  75. within a second, would it really be worth it
  76. to set the parent dir cifs inode time to zero
  77. to force revalidate (faster) for it too? */
  78. }
  79. /* if not oplocked will force revalidate to get info
  80. on source file from srv */
  81. cifsInode->time = 0;
  82. /* Will update parent dir timestamps from srv within a second.
  83. Would it really be worth it to set the parent dir (cifs
  84. inode) time field to zero to force revalidate on parent
  85. directory faster ie
  86. CIFS_I(inode)->time = 0; */
  87. }
  88. cifs_hl_exit:
  89. kfree(fromName);
  90. kfree(toName);
  91. FreeXid(xid);
  92. return rc;
  93. }
  94. void *
  95. cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
  96. {
  97. struct inode *inode = direntry->d_inode;
  98. int rc = -EACCES;
  99. int xid;
  100. char *full_path = NULL;
  101. char * target_path = ERR_PTR(-ENOMEM);
  102. struct cifs_sb_info *cifs_sb;
  103. struct cifsTconInfo *pTcon;
  104. xid = GetXid();
  105. full_path = build_path_from_dentry(direntry);
  106. if (!full_path)
  107. goto out_no_free;
  108. cFYI(1, ("Full path: %s inode = 0x%p", full_path, inode));
  109. cifs_sb = CIFS_SB(inode->i_sb);
  110. pTcon = cifs_sb->tcon;
  111. target_path = kmalloc(PATH_MAX, GFP_KERNEL);
  112. if (!target_path) {
  113. target_path = ERR_PTR(-ENOMEM);
  114. goto out;
  115. }
  116. /* BB add read reparse point symlink code and Unix extensions symlink code here BB */
  117. if (pTcon->ses->capabilities & CAP_UNIX)
  118. rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
  119. target_path,
  120. PATH_MAX-1,
  121. cifs_sb->local_nls);
  122. else {
  123. /* rc = CIFSSMBQueryReparseLinkInfo */
  124. /* BB Add code to Query ReparsePoint info */
  125. /* BB Add MAC style xsymlink check here if enabled */
  126. }
  127. if (rc == 0) {
  128. /* BB Add special case check for Samba DFS symlinks */
  129. target_path[PATH_MAX-1] = 0;
  130. } else {
  131. kfree(target_path);
  132. target_path = ERR_PTR(rc);
  133. }
  134. out:
  135. kfree(full_path);
  136. out_no_free:
  137. FreeXid(xid);
  138. nd_set_link(nd, target_path);
  139. return NULL; /* No cookie */
  140. }
  141. int
  142. cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
  143. {
  144. int rc = -EOPNOTSUPP;
  145. int xid;
  146. struct cifs_sb_info *cifs_sb;
  147. struct cifsTconInfo *pTcon;
  148. char *full_path = NULL;
  149. struct inode *newinode = NULL;
  150. xid = GetXid();
  151. cifs_sb = CIFS_SB(inode->i_sb);
  152. pTcon = cifs_sb->tcon;
  153. full_path = build_path_from_dentry(direntry);
  154. if(full_path == NULL) {
  155. FreeXid(xid);
  156. return -ENOMEM;
  157. }
  158. cFYI(1, ("Full path: %s", full_path));
  159. cFYI(1, ("symname is %s", symname));
  160. /* BB what if DFS and this volume is on different share? BB */
  161. if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
  162. rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
  163. cifs_sb->local_nls);
  164. /* else
  165. rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,cifs_sb_target->local_nls); */
  166. if (rc == 0) {
  167. if (pTcon->ses->capabilities & CAP_UNIX)
  168. rc = cifs_get_inode_info_unix(&newinode, full_path,
  169. inode->i_sb,xid);
  170. else
  171. rc = cifs_get_inode_info(&newinode, full_path, NULL,
  172. inode->i_sb,xid);
  173. if (rc != 0) {
  174. cFYI(1, ("Create symlink ok, getinodeinfo fail rc = %d",
  175. rc));
  176. } else {
  177. if (pTcon->nocase)
  178. direntry->d_op = &cifs_ci_dentry_ops;
  179. else
  180. direntry->d_op = &cifs_dentry_ops;
  181. d_instantiate(direntry, newinode);
  182. }
  183. }
  184. kfree(full_path);
  185. FreeXid(xid);
  186. return rc;
  187. }
  188. int
  189. cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
  190. {
  191. struct inode *inode = direntry->d_inode;
  192. int rc = -EACCES;
  193. int xid;
  194. int oplock = FALSE;
  195. struct cifs_sb_info *cifs_sb;
  196. struct cifsTconInfo *pTcon;
  197. char *full_path = NULL;
  198. char *tmp_path = NULL;
  199. char * tmpbuffer;
  200. unsigned char * referrals = NULL;
  201. int num_referrals = 0;
  202. int len;
  203. __u16 fid;
  204. xid = GetXid();
  205. cifs_sb = CIFS_SB(inode->i_sb);
  206. pTcon = cifs_sb->tcon;
  207. /* BB would it be safe against deadlock to grab this sem
  208. even though rename itself grabs the sem and calls lookup? */
  209. /* mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/
  210. full_path = build_path_from_dentry(direntry);
  211. /* mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/
  212. if(full_path == NULL) {
  213. FreeXid(xid);
  214. return -ENOMEM;
  215. }
  216. cFYI(1,
  217. ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",
  218. full_path, inode, pBuffer, buflen));
  219. if(buflen > PATH_MAX)
  220. len = PATH_MAX;
  221. else
  222. len = buflen;
  223. tmpbuffer = kmalloc(len,GFP_KERNEL);
  224. if(tmpbuffer == NULL) {
  225. kfree(full_path);
  226. FreeXid(xid);
  227. return -ENOMEM;
  228. }
  229. /* BB add read reparse point symlink code and Unix extensions symlink code here BB */
  230. if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
  231. rc = CIFSSMBUnixQuerySymLink(xid, pTcon, full_path,
  232. tmpbuffer,
  233. len - 1,
  234. cifs_sb->local_nls);
  235. else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
  236. cERROR(1,("SFU style symlinks not implemented yet"));
  237. /* add open and read as in fs/cifs/inode.c */
  238. } else {
  239. rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,
  240. OPEN_REPARSE_POINT,&fid, &oplock, NULL,
  241. cifs_sb->local_nls,
  242. cifs_sb->mnt_cifs_flags &
  243. CIFS_MOUNT_MAP_SPECIAL_CHR);
  244. if(!rc) {
  245. rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
  246. tmpbuffer,
  247. len - 1,
  248. fid,
  249. cifs_sb->local_nls);
  250. if(CIFSSMBClose(xid, pTcon, fid)) {
  251. cFYI(1,("Error closing junction point (open for ioctl)"));
  252. }
  253. if(rc == -EIO) {
  254. /* Query if DFS Junction */
  255. tmp_path =
  256. kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,
  257. GFP_KERNEL);
  258. if (tmp_path) {
  259. strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
  260. strncat(tmp_path, full_path, MAX_PATHCONF);
  261. rc = get_dfs_path(xid, pTcon->ses, tmp_path,
  262. cifs_sb->local_nls,
  263. &num_referrals, &referrals,
  264. cifs_sb->mnt_cifs_flags &
  265. CIFS_MOUNT_MAP_SPECIAL_CHR);
  266. cFYI(1,("Get DFS for %s rc = %d ",tmp_path, rc));
  267. if((num_referrals == 0) && (rc == 0))
  268. rc = -EACCES;
  269. else {
  270. cFYI(1,("num referral: %d",num_referrals));
  271. if(referrals) {
  272. cFYI(1,("referral string: %s",referrals));
  273. strncpy(tmpbuffer, referrals, len-1);
  274. }
  275. }
  276. kfree(referrals);
  277. kfree(tmp_path);
  278. }
  279. /* BB add code like else decode referrals then memcpy to
  280. tmpbuffer and free referrals string array BB */
  281. }
  282. }
  283. }
  284. /* BB Anything else to do to handle recursive links? */
  285. /* BB Should we be using page ops here? */
  286. /* BB null terminate returned string in pBuffer? BB */
  287. if (rc == 0) {
  288. rc = vfs_readlink(direntry, pBuffer, len, tmpbuffer);
  289. cFYI(1,
  290. ("vfs_readlink called from cifs_readlink returned %d",
  291. rc));
  292. }
  293. kfree(tmpbuffer);
  294. kfree(full_path);
  295. FreeXid(xid);
  296. return rc;
  297. }
  298. void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
  299. {
  300. char *p = nd_get_link(nd);
  301. if (!IS_ERR(p))
  302. kfree(p);
  303. }