1
2
3
4
5
6
7
8#include <linux/namei.h>
9#include <linux/vbox_utils.h>
10#include "vfsmod.h"
11
12static int vboxsf_dir_open(struct inode *inode, struct file *file)
13{
14 struct vboxsf_sbi *sbi = VBOXSF_SBI(inode->i_sb);
15 struct shfl_createparms params = {};
16 struct vboxsf_dir_info *sf_d;
17 int err;
18
19 sf_d = vboxsf_dir_info_alloc();
20 if (!sf_d)
21 return -ENOMEM;
22
23 params.handle = SHFL_HANDLE_NIL;
24 params.create_flags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS |
25 SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
26
27 err = vboxsf_create_at_dentry(file_dentry(file), ¶ms);
28 if (err)
29 goto err_free_dir_info;
30
31 if (params.result != SHFL_FILE_EXISTS) {
32 err = -ENOENT;
33 goto err_close;
34 }
35
36 err = vboxsf_dir_read_all(sbi, sf_d, params.handle);
37 if (err)
38 goto err_close;
39
40 vboxsf_close(sbi->root, params.handle);
41 file->private_data = sf_d;
42 return 0;
43
44err_close:
45 vboxsf_close(sbi->root, params.handle);
46err_free_dir_info:
47 vboxsf_dir_info_free(sf_d);
48 return err;
49}
50
51static int vboxsf_dir_release(struct inode *inode, struct file *file)
52{
53 if (file->private_data)
54 vboxsf_dir_info_free(file->private_data);
55
56 return 0;
57}
58
59static unsigned int vboxsf_get_d_type(u32 mode)
60{
61 unsigned int d_type;
62
63 switch (mode & SHFL_TYPE_MASK) {
64 case SHFL_TYPE_FIFO:
65 d_type = DT_FIFO;
66 break;
67 case SHFL_TYPE_DEV_CHAR:
68 d_type = DT_CHR;
69 break;
70 case SHFL_TYPE_DIRECTORY:
71 d_type = DT_DIR;
72 break;
73 case SHFL_TYPE_DEV_BLOCK:
74 d_type = DT_BLK;
75 break;
76 case SHFL_TYPE_FILE:
77 d_type = DT_REG;
78 break;
79 case SHFL_TYPE_SYMLINK:
80 d_type = DT_LNK;
81 break;
82 case SHFL_TYPE_SOCKET:
83 d_type = DT_SOCK;
84 break;
85 case SHFL_TYPE_WHITEOUT:
86 d_type = DT_WHT;
87 break;
88 default:
89 d_type = DT_UNKNOWN;
90 break;
91 }
92 return d_type;
93}
94
95static bool vboxsf_dir_emit(struct file *dir, struct dir_context *ctx)
96{
97 struct vboxsf_sbi *sbi = VBOXSF_SBI(file_inode(dir)->i_sb);
98 struct vboxsf_dir_info *sf_d = dir->private_data;
99 struct shfl_dirinfo *info;
100 struct vboxsf_dir_buf *b;
101 unsigned int d_type;
102 loff_t i, cur = 0;
103 ino_t fake_ino;
104 void *end;
105 int err;
106
107 list_for_each_entry(b, &sf_d->info_list, head) {
108try_next_entry:
109 if (ctx->pos >= cur + b->entries) {
110 cur += b->entries;
111 continue;
112 }
113
114
115
116
117
118
119
120
121 for (i = 0, info = b->buf; i < ctx->pos - cur; i++) {
122 end = &info->name.string.utf8[info->name.size];
123
124 if (WARN_ON(end > (b->buf + b->used)))
125 return false;
126 info = end;
127 }
128
129 end = &info->name.string.utf8[info->name.size];
130 if (WARN_ON(end > (b->buf + b->used)))
131 return false;
132
133
134 d_type = vboxsf_get_d_type(info->info.attr.mode);
135
136
137
138
139
140 if ((ino_t)(ctx->pos + 1) != (u64)(ctx->pos + 1)) {
141 vbg_err("vboxsf: fake ino overflow, truncating dir\n");
142 return false;
143 }
144 fake_ino = ctx->pos + 1;
145
146 if (sbi->nls) {
147 char d_name[NAME_MAX];
148
149 err = vboxsf_nlscpy(sbi, d_name, NAME_MAX,
150 info->name.string.utf8,
151 info->name.length);
152 if (err) {
153
154 ctx->pos += 1;
155 goto try_next_entry;
156 }
157
158 return dir_emit(ctx, d_name, strlen(d_name),
159 fake_ino, d_type);
160 }
161
162 return dir_emit(ctx, info->name.string.utf8, info->name.length,
163 fake_ino, d_type);
164 }
165
166 return false;
167}
168
169static int vboxsf_dir_iterate(struct file *dir, struct dir_context *ctx)
170{
171 bool emitted;
172
173 do {
174 emitted = vboxsf_dir_emit(dir, ctx);
175 if (emitted)
176 ctx->pos += 1;
177 } while (emitted);
178
179 return 0;
180}
181
182const struct file_operations vboxsf_dir_fops = {
183 .open = vboxsf_dir_open,
184 .iterate = vboxsf_dir_iterate,
185 .release = vboxsf_dir_release,
186 .read = generic_read_dir,
187 .llseek = generic_file_llseek,
188};
189
190
191
192
193
194static int vboxsf_dentry_revalidate(struct dentry *dentry, unsigned int flags)
195{
196 if (flags & LOOKUP_RCU)
197 return -ECHILD;
198
199 if (d_really_is_positive(dentry))
200 return vboxsf_inode_revalidate(dentry) == 0;
201 else
202 return vboxsf_stat_dentry(dentry, NULL) == -ENOENT;
203}
204
205const struct dentry_operations vboxsf_dentry_ops = {
206 .d_revalidate = vboxsf_dentry_revalidate
207};
208
209
210
211static struct dentry *vboxsf_dir_lookup(struct inode *parent,
212 struct dentry *dentry,
213 unsigned int flags)
214{
215 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
216 struct shfl_fsobjinfo fsinfo;
217 struct inode *inode;
218 int err;
219
220 dentry->d_time = jiffies;
221
222 err = vboxsf_stat_dentry(dentry, &fsinfo);
223 if (err) {
224 inode = (err == -ENOENT) ? NULL : ERR_PTR(err);
225 } else {
226 inode = vboxsf_new_inode(parent->i_sb);
227 if (!IS_ERR(inode))
228 vboxsf_init_inode(sbi, inode, &fsinfo, false);
229 }
230
231 return d_splice_alias(inode, dentry);
232}
233
234static int vboxsf_dir_instantiate(struct inode *parent, struct dentry *dentry,
235 struct shfl_fsobjinfo *info)
236{
237 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
238 struct vboxsf_inode *sf_i;
239 struct inode *inode;
240
241 inode = vboxsf_new_inode(parent->i_sb);
242 if (IS_ERR(inode))
243 return PTR_ERR(inode);
244
245 sf_i = VBOXSF_I(inode);
246
247 sf_i->force_restat = 1;
248 vboxsf_init_inode(sbi, inode, info, false);
249
250 d_instantiate(dentry, inode);
251
252 return 0;
253}
254
255static int vboxsf_dir_create(struct inode *parent, struct dentry *dentry,
256 umode_t mode, bool is_dir, bool excl, u64 *handle_ret)
257{
258 struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
259 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
260 struct shfl_createparms params = {};
261 int err;
262
263 params.handle = SHFL_HANDLE_NIL;
264 params.create_flags = SHFL_CF_ACT_CREATE_IF_NEW | SHFL_CF_ACCESS_READWRITE;
265 if (is_dir)
266 params.create_flags |= SHFL_CF_DIRECTORY;
267 if (excl)
268 params.create_flags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
269
270 params.info.attr.mode = (mode & 0777) |
271 (is_dir ? SHFL_TYPE_DIRECTORY : SHFL_TYPE_FILE);
272 params.info.attr.additional = SHFLFSOBJATTRADD_NOTHING;
273
274 err = vboxsf_create_at_dentry(dentry, ¶ms);
275 if (err)
276 return err;
277
278 if (params.result != SHFL_FILE_CREATED)
279 return -EPERM;
280
281 err = vboxsf_dir_instantiate(parent, dentry, ¶ms.info);
282 if (err)
283 goto out;
284
285
286 sf_parent_i->force_restat = 1;
287
288out:
289 if (err == 0 && handle_ret)
290 *handle_ret = params.handle;
291 else
292 vboxsf_close(sbi->root, params.handle);
293
294 return err;
295}
296
297static int vboxsf_dir_mkfile(struct user_namespace *mnt_userns,
298 struct inode *parent, struct dentry *dentry,
299 umode_t mode, bool excl)
300{
301 return vboxsf_dir_create(parent, dentry, mode, false, excl, NULL);
302}
303
304static int vboxsf_dir_mkdir(struct user_namespace *mnt_userns,
305 struct inode *parent, struct dentry *dentry,
306 umode_t mode)
307{
308 return vboxsf_dir_create(parent, dentry, mode, true, true, NULL);
309}
310
311static int vboxsf_dir_atomic_open(struct inode *parent, struct dentry *dentry,
312 struct file *file, unsigned int flags, umode_t mode)
313{
314 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
315 struct vboxsf_handle *sf_handle;
316 struct dentry *res = NULL;
317 u64 handle;
318 int err;
319
320 if (d_in_lookup(dentry)) {
321 res = vboxsf_dir_lookup(parent, dentry, 0);
322 if (IS_ERR(res))
323 return PTR_ERR(res);
324
325 if (res)
326 dentry = res;
327 }
328
329
330 if (!(flags & O_CREAT) || d_really_is_positive(dentry))
331 return finish_no_open(file, res);
332
333 err = vboxsf_dir_create(parent, dentry, mode, false, flags & O_EXCL, &handle);
334 if (err)
335 goto out;
336
337 sf_handle = vboxsf_create_sf_handle(d_inode(dentry), handle, SHFL_CF_ACCESS_READWRITE);
338 if (IS_ERR(sf_handle)) {
339 vboxsf_close(sbi->root, handle);
340 err = PTR_ERR(sf_handle);
341 goto out;
342 }
343
344 err = finish_open(file, dentry, generic_file_open);
345 if (err) {
346
347 vboxsf_release_sf_handle(d_inode(dentry), sf_handle);
348 goto out;
349 }
350
351 file->private_data = sf_handle;
352 file->f_mode |= FMODE_CREATED;
353out:
354 dput(res);
355 return err;
356}
357
358static int vboxsf_dir_unlink(struct inode *parent, struct dentry *dentry)
359{
360 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
361 struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
362 struct inode *inode = d_inode(dentry);
363 struct shfl_string *path;
364 u32 flags;
365 int err;
366
367 if (S_ISDIR(inode->i_mode))
368 flags = SHFL_REMOVE_DIR;
369 else
370 flags = SHFL_REMOVE_FILE;
371
372 if (S_ISLNK(inode->i_mode))
373 flags |= SHFL_REMOVE_SYMLINK;
374
375 path = vboxsf_path_from_dentry(sbi, dentry);
376 if (IS_ERR(path))
377 return PTR_ERR(path);
378
379 err = vboxsf_remove(sbi->root, path, flags);
380 __putname(path);
381 if (err)
382 return err;
383
384
385 sf_parent_i->force_restat = 1;
386
387 return 0;
388}
389
390static int vboxsf_dir_rename(struct user_namespace *mnt_userns,
391 struct inode *old_parent,
392 struct dentry *old_dentry,
393 struct inode *new_parent,
394 struct dentry *new_dentry,
395 unsigned int flags)
396{
397 struct vboxsf_sbi *sbi = VBOXSF_SBI(old_parent->i_sb);
398 struct vboxsf_inode *sf_old_parent_i = VBOXSF_I(old_parent);
399 struct vboxsf_inode *sf_new_parent_i = VBOXSF_I(new_parent);
400 u32 shfl_flags = SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS;
401 struct shfl_string *old_path, *new_path;
402 int err;
403
404 if (flags)
405 return -EINVAL;
406
407 old_path = vboxsf_path_from_dentry(sbi, old_dentry);
408 if (IS_ERR(old_path))
409 return PTR_ERR(old_path);
410
411 new_path = vboxsf_path_from_dentry(sbi, new_dentry);
412 if (IS_ERR(new_path)) {
413 err = PTR_ERR(new_path);
414 goto err_put_old_path;
415 }
416
417 if (d_inode(old_dentry)->i_mode & S_IFDIR)
418 shfl_flags = 0;
419
420 err = vboxsf_rename(sbi->root, old_path, new_path, shfl_flags);
421 if (err == 0) {
422
423 sf_new_parent_i->force_restat = 1;
424 sf_old_parent_i->force_restat = 1;
425 }
426
427 __putname(new_path);
428err_put_old_path:
429 __putname(old_path);
430 return err;
431}
432
433static int vboxsf_dir_symlink(struct user_namespace *mnt_userns,
434 struct inode *parent, struct dentry *dentry,
435 const char *symname)
436{
437 struct vboxsf_inode *sf_parent_i = VBOXSF_I(parent);
438 struct vboxsf_sbi *sbi = VBOXSF_SBI(parent->i_sb);
439 int symname_size = strlen(symname) + 1;
440 struct shfl_string *path, *ssymname;
441 struct shfl_fsobjinfo info;
442 int err;
443
444 path = vboxsf_path_from_dentry(sbi, dentry);
445 if (IS_ERR(path))
446 return PTR_ERR(path);
447
448 ssymname = kmalloc(SHFLSTRING_HEADER_SIZE + symname_size, GFP_KERNEL);
449 if (!ssymname) {
450 __putname(path);
451 return -ENOMEM;
452 }
453 ssymname->length = symname_size - 1;
454 ssymname->size = symname_size;
455 memcpy(ssymname->string.utf8, symname, symname_size);
456
457 err = vboxsf_symlink(sbi->root, path, ssymname, &info);
458 kfree(ssymname);
459 __putname(path);
460 if (err) {
461
462 return (err == -EROFS) ? -EPERM : err;
463 }
464
465 err = vboxsf_dir_instantiate(parent, dentry, &info);
466 if (err)
467 return err;
468
469
470 sf_parent_i->force_restat = 1;
471 return 0;
472}
473
474const struct inode_operations vboxsf_dir_iops = {
475 .lookup = vboxsf_dir_lookup,
476 .create = vboxsf_dir_mkfile,
477 .mkdir = vboxsf_dir_mkdir,
478 .atomic_open = vboxsf_dir_atomic_open,
479 .rmdir = vboxsf_dir_unlink,
480 .unlink = vboxsf_dir_unlink,
481 .rename = vboxsf_dir_rename,
482 .symlink = vboxsf_dir_symlink,
483 .getattr = vboxsf_getattr,
484 .setattr = vboxsf_setattr,
485};
486
