dir.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. // SPDX-License-Identifier: MIT
  2. /*
  3. * VirtualBox Guest Shared Folders support: Directory inode and file operations
  4. *
  5. * Copyright (C) 2006-2018 Oracle Corporation
  6. */
  7. #include <linux/namei.h>
  8. #include <linux/vbox_utils.h>
  9. #include "vfsmod.h"
  10. static int vboxsf_dir_open(struct inode *inode, struct file *file)
  11. {
  12. struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
  13. struct shfl_createparms params = {};
  14. struct vboxsf_dir_info *sf_d;
  15. int err;
  16. sf_d = vboxsf_dir_info_alloc();
  17. if (!sf_d)
  18. return -ENOMEM;
  19. params.handle = SHFL_HANDLE_NIL;
  20. params.create_flags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS |
  21. SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
  22. err = vboxsf_create_at_dentry(file_dentry(file), &params);
  23. if (err)
  24. goto err_free_dir_info;
  25. if (params.result != SHFL_FILE_EXISTS) {
  26. err = -ENOENT;
  27. goto err_close;
  28. }
  29. err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
  30. if (err)
  31. goto err_close;
  32. vboxsf_close(sbi->root, params.handle);
  33. file->private_data = sf_d;
  34. return 0;
  35. err_close:
  36. vboxsf_close(sbi->root, params.handle);
  37. err_free_dir_info:
  38. vboxsf_dir_info_free(sf_d);
  39. return err;
  40. }
  41. static int vboxsf_dir_release(struct inode *inode, struct file *file)
  42. {
  43. if (file->private_data)
  44. vboxsf_dir_info_free(file->private_data);
  45. return 0;
  46. }
  47. static unsigned int vboxsf_get_d_type(u32 mode)
  48. {
  49. unsigned int d_type;
  50. switch (mode & SHFL_TYPE_MASK) {
  51. case SHFL_TYPE_FIFO:
  52. d_type = DT_FIFO;
  53. break;
  54. case SHFL_TYPE_DEV_CHAR:
  55. d_type = DT_CHR;
  56. break;
  57. case SHFL_TYPE_DIRECTORY:
  58. d_type = DT_DIR;
  59. break;
  60. case SHFL_TYPE_DEV_BLOCK:
  61. d_type = DT_BLK;
  62. break;
  63. case SHFL_TYPE_FILE:
  64. d_type = DT_REG;
  65. break;
  66. case SHFL_TYPE_SYMLINK:
  67. d_type = DT_LNK;
  68. break;
  69. case SHFL_TYPE_SOCKET:
  70. d_type = DT_SOCK;
  71. break;
  72. case SHFL_TYPE_WHITEOUT:
  73. d_type = DT_WHT;
  74. break;
  75. default:
  76. d_type = DT_UNKNOWN;
  77. break;
  78. }
  79. return d_type;
  80. }
  81. static bool vboxsf_dir_emit(struct file *dir, struct dir_context *ctx)
  82. {
  83. struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
  84. struct vboxsf_dir_info *sf_d = dir->private_data;
  85. struct shfl_dirinfo *info;
  86. struct vboxsf_dir_buf *b;
  87. unsigned int d_type;
  88. loff_t i, cur = 0;
  89. ino_t fake_ino;
  90. void *end;
  91. int err;
  92. list_for_each_entry(b, &sf_d->info_list, head) {
  93. try_next_entry:
  94. if (ctx->pos >= cur + b->entries) {
  95. cur += b->entries;
  96. continue;
  97. }
  98. /*
  99. * Note the vboxsf_dir_info objects we are iterating over here
  100. * are variable sized, so the info pointer may end up being
  101. * unaligned. This is how we get the data from the host.
  102. * Since vboxsf is only supported on x86 machines this is not
  103. * a problem.
  104. */
  105. for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
  106. end = &info->name.string.utf8[info->name.size];
  107. /* Only happens if the host gives us corrupt data */
  108. if (WARN_ON(end > (b->buf + b->used)))
  109. return false;
  110. info = end;
  111. }
  112. end = &info->name.string.utf8[info->name.size];
  113. if (WARN_ON(end > (b->buf + b->used)))
  114. return false;
  115. /* Info now points to the right entry, emit it. */
  116. d_type = vboxsf_get_d_type(info->info.attr.mode);
  117. /*
  118. * On 32-bit systems pos is 64-bit signed, while ino is 32-bit
  119. * unsigned so fake_ino may overflow, check for this.
  120. */
  121. if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
  122. vbg_err("vboxsf: fake ino overflow, truncating dir\n");
  123. return false;
  124. }
  125. fake_ino = ctx->pos + 1;
  126. if (sbi->nls) {
  127. char d_name[NAME_MAX];
  128. err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
  129. info->name.string.utf8,
  130. info->name.length);
  131. if (err) {
  132. /* skip erroneous entry and proceed */
  133. ctx->pos += 1;
  134. goto try_next_entry;
  135. }
  136. return dir_emit(ctx, d_name, strlen(d_name),
  137. fake_ino, d_type);
  138. }
  139. return dir_emit(ctx, info->name.string.utf8, info->name.length,
  140. fake_ino, d_type);
  141. }
  142. return false;
  143. }
  144. static int vboxsf_dir_iterate(struct file *dir, struct dir_context *ctx)
  145. {
  146. bool emitted;
  147. do {
  148. emitted = vboxsf_dir_emit(dir, ctx);
  149. if (emitted)
  150. ctx->pos += 1;
  151. } while (emitted);
  152. return 0;
  153. }
  154. const struct file_operations vboxsf_dir_fops = {
  155. .open = vboxsf_dir_open,
  156. .iterate = vboxsf_dir_iterate,
  157. .release = vboxsf_dir_release,
  158. .read = generic_read_dir,
  159. .llseek = generic_file_llseek,
  160. };
  161. /*
  162. * This is called during name resolution/lookup to check if the @dentry in
  163. * the cache is still valid. the job is handled by vboxsf_inode_revalidate.
  164. */
  165. static int vboxsf_dentry_revalidate(struct dentry *dentry, unsigned int flags)
  166. {
  167. if (flags & LOOKUP_RCU)
  168. return -ECHILD;
  169. if (d_really_is_positive(dentry))
  170. return vboxsf_inode_revalidate(dentry) == 0;
  171. else
  172. return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
  173. }
  174. const struct dentry_operations vboxsf_dentry_ops = {
  175. .d_revalidate = vboxsf_dentry_revalidate
  176. };
  177. /* iops */
  178. static struct dentry *vboxsf_dir_lookup(struct inode *parent,
  179. struct dentry *dentry,
  180. unsigned int flags)
  181. {
  182. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  183. struct shfl_fsobjinfo fsinfo;
  184. struct inode *inode;
  185. int err;
  186. dentry->d_time = jiffies;
  187. err = vboxsf_stat_dentry(dentry, &fsinfo);
  188. if (err) {
  189. inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
  190. } else {
  191. inode = vboxsf_new_inode(parent->i_sb);
  192. if (!IS_ERR(inode))
  193. vboxsf_init_inode(sbi, inode, &fsinfo);
  194. }
  195. return d_splice_alias(inode, dentry);
  196. }
  197. static int vboxsf_dir_instantiate(struct inode *parent, struct dentry *dentry,
  198. struct shfl_fsobjinfo *info)
  199. {
  200. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  201. struct vboxsf_inode *sf_i;
  202. struct inode *inode;
  203. inode = vboxsf_new_inode(parent->i_sb);
  204. if (IS_ERR(inode))
  205. return PTR_ERR(inode);
  206. sf_i = VBOXSF_I(inode);
  207. /* The host may have given us different attr then requested */
  208. sf_i->force_restat = 1;
  209. vboxsf_init_inode(sbi, inode, info);
  210. d_instantiate(dentry, inode);
  211. return 0;
  212. }
  213. static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
  214. umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
  215. {
  216. struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
  217. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  218. struct shfl_createparms params = {};
  219. int err;
  220. params.handle = SHFL_HANDLE_NIL;
  221. params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW | SHFL_CF_ACCESS_READWRITE;
  222. if (is_dir)
  223. params.create_flags |= SHFL_CF_DIRECTORY;
  224. if (excl)
  225. params.create_flags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
  226. params.info.attr.mode = (mode & 0777) |
  227. (is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
  228. params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;
  229. err = vboxsf_create_at_dentry(dentry, &params);
  230. if (err)
  231. return err;
  232. if (params.result != SHFL_FILE_CREATED)
  233. return -EPERM;
  234. err = vboxsf_dir_instantiate(parent, dentry, &params.info);
  235. if (err)
  236. goto out;
  237. /* parent directory access/change time changed */
  238. sf_parent_i->force_restat = 1;
  239. out:
  240. if (err == 0 && handle_ret)
  241. *handle_ret = params.handle;
  242. else
  243. vboxsf_close(sbi->root, params.handle);
  244. return err;
  245. }
  246. static int vboxsf_dir_mkfile(struct inode *parent, struct dentry *dentry,
  247. umode_t mode, bool excl)
  248. {
  249. return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
  250. }
  251. static int vboxsf_dir_mkdir(struct inode *parent, struct dentry *dentry,
  252. umode_t mode)
  253. {
  254. return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
  255. }
  256. static int vboxsf_dir_atomic_open(struct inode *parent, struct dentry *dentry,
  257. struct file *file, unsigned int flags, umode_t mode)
  258. {
  259. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  260. struct vboxsf_handle *sf_handle;
  261. struct dentry *res = NULL;
  262. u64 handle;
  263. int err;
  264. if (d_in_lookup(dentry)) {
  265. res = vboxsf_dir_lookup(parent, dentry, 0);
  266. if (IS_ERR(res))
  267. return PTR_ERR(res);
  268. if (res)
  269. dentry = res;
  270. }
  271. /* Only creates */
  272. if (!(flags & O_CREAT) || d_really_is_positive(dentry))
  273. return finish_no_open(file, res);
  274. err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
  275. if (err)
  276. goto out;
  277. sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
  278. if (IS_ERR(sf_handle)) {
  279. vboxsf_close(sbi->root, handle);
  280. err = PTR_ERR(sf_handle);
  281. goto out;
  282. }
  283. err = finish_open(file, dentry, generic_file_open);
  284. if (err) {
  285. /* This also closes the handle passed to vboxsf_create_sf_handle() */
  286. vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
  287. goto out;
  288. }
  289. file->private_data = sf_handle;
  290. file->f_mode |= FMODE_CREATED;
  291. out:
  292. dput(res);
  293. return err;
  294. }
  295. static int vboxsf_dir_unlink(struct inode *parent, struct dentry *dentry)
  296. {
  297. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  298. struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
  299. struct inode *inode = d_inode(dentry);
  300. struct shfl_string *path;
  301. u32 flags;
  302. int err;
  303. if (S_ISDIR(inode->i_mode))
  304. flags = SHFL_REMOVE_DIR;
  305. else
  306. flags = SHFL_REMOVE_FILE;
  307. if (S_ISLNK(inode->i_mode))
  308. flags |= SHFL_REMOVE_SYMLINK;
  309. path = vboxsf_path_from_dentry(sbi, dentry);
  310. if (IS_ERR(path))
  311. return PTR_ERR(path);
  312. err = vboxsf_remove(sbi->root, path, flags);
  313. __putname(path);
  314. if (err)
  315. return err;
  316. /* parent directory access/change time changed */
  317. sf_parent_i->force_restat = 1;
  318. return 0;
  319. }
  320. static int vboxsf_dir_rename(struct inode *old_parent,
  321. struct dentry *old_dentry,
  322. struct inode *new_parent,
  323. struct dentry *new_dentry,
  324. unsigned int flags)
  325. {
  326. struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
  327. struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
  328. struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
  329. u32 shfl_flags = SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS;
  330. struct shfl_string *old_path, *new_path;
  331. int err;
  332. if (flags)
  333. return -EINVAL;
  334. old_path = vboxsf_path_from_dentry(sbi, old_dentry);
  335. if (IS_ERR(old_path))
  336. return PTR_ERR(old_path);
  337. new_path = vboxsf_path_from_dentry(sbi, new_dentry);
  338. if (IS_ERR(new_path)) {
  339. err = PTR_ERR(new_path);
  340. goto err_put_old_path;
  341. }
  342. if (d_inode(old_dentry)->i_mode & S_IFDIR)
  343. shfl_flags = 0;
  344. err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
  345. if (err == 0) {
  346. /* parent directories access/change time changed */
  347. sf_new_parent_i->force_restat = 1;
  348. sf_old_parent_i->force_restat = 1;
  349. }
  350. __putname(new_path);
  351. err_put_old_path:
  352. __putname(old_path);
  353. return err;
  354. }
  355. static int vboxsf_dir_symlink(struct inode *parent, struct dentry *dentry,
  356. const char *symname)
  357. {
  358. struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
  359. struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
  360. int symname_size = strlen(symname) + 1;
  361. struct shfl_string *path, *ssymname;
  362. struct shfl_fsobjinfo info;
  363. int err;
  364. path = vboxsf_path_from_dentry(sbi, dentry);
  365. if (IS_ERR(path))
  366. return PTR_ERR(path);
  367. ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
  368. if (!ssymname) {
  369. __putname(path);
  370. return -ENOMEM;
  371. }
  372. ssymname->length = symname_size - 1;
  373. ssymname->size = symname_size;
  374. memcpy(ssymname->string.utf8, symname, symname_size);
  375. err = vboxsf_symlink(sbi->root, path, ssymname, &info);
  376. kfree(ssymname);
  377. __putname(path);
  378. if (err) {
  379. /* -EROFS means symlinks are note support -> -EPERM */
  380. return (err == -EROFS) ? -EPERM : err;
  381. }
  382. err = vboxsf_dir_instantiate(parent, dentry, &info);
  383. if (err)
  384. return err;
  385. /* parent directory access/change time changed */
  386. sf_parent_i->force_restat = 1;
  387. return 0;
  388. }
  389. const struct inode_operations vboxsf_dir_iops = {
  390. .lookup = vboxsf_dir_lookup,
  391. .create = vboxsf_dir_mkfile,
  392. .mkdir = vboxsf_dir_mkdir,
  393. .atomic_open = vboxsf_dir_atomic_open,
  394. .rmdir = vboxsf_dir_unlink,
  395. .unlink = vboxsf_dir_unlink,
  396. .rename = vboxsf_dir_rename,
  397. .symlink = vboxsf_dir_symlink,
  398. .getattr = vboxsf_getattr,
  399. .setattr = vboxsf_setattr,
  400. };