Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * dir.c | |
3 | * | |
4 | * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke | |
5 | * Copyright (C) 1997 by Volker Lendecke | |
6 | * | |
7 | * Please add a note about your changes to smbfs in the ChangeLog file. | |
8 | */ | |
9 | ||
10 | #include <linux/time.h> | |
11 | #include <linux/errno.h> | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/smp_lock.h> | |
14 | #include <linux/ctype.h> | |
15 | #include <linux/net.h> | |
e8edc6e0 | 16 | #include <linux/sched.h> |
34286d66 | 17 | #include <linux/namei.h> |
1da177e4 | 18 | |
2116b7a4 AB |
19 | #include "smb_fs.h" |
20 | #include "smb_mount.h" | |
21 | #include "smbno.h" | |
1da177e4 LT |
22 | |
23 | #include "smb_debug.h" | |
24 | #include "proto.h" | |
25 | ||
26 | static int smb_readdir(struct file *, void *, filldir_t); | |
27 | static int smb_dir_open(struct inode *, struct file *); | |
28 | ||
29 | static struct dentry *smb_lookup(struct inode *, struct dentry *, struct nameidata *); | |
30 | static int smb_create(struct inode *, struct dentry *, int, struct nameidata *); | |
31 | static int smb_mkdir(struct inode *, struct dentry *, int); | |
32 | static int smb_rmdir(struct inode *, struct dentry *); | |
33 | static int smb_unlink(struct inode *, struct dentry *); | |
34 | static int smb_rename(struct inode *, struct dentry *, | |
35 | struct inode *, struct dentry *); | |
36 | static int smb_make_node(struct inode *,struct dentry *,int,dev_t); | |
37 | static int smb_link(struct dentry *, struct inode *, struct dentry *); | |
38 | ||
4b6f5d20 | 39 | const struct file_operations smb_dir_operations = |
1da177e4 | 40 | { |
ca572727 | 41 | .llseek = generic_file_llseek, |
1da177e4 LT |
42 | .read = generic_read_dir, |
43 | .readdir = smb_readdir, | |
ce8273a5 | 44 | .unlocked_ioctl = smb_ioctl, |
1da177e4 LT |
45 | .open = smb_dir_open, |
46 | }; | |
47 | ||
c5ef1c42 | 48 | const struct inode_operations smb_dir_inode_operations = |
1da177e4 LT |
49 | { |
50 | .create = smb_create, | |
51 | .lookup = smb_lookup, | |
52 | .unlink = smb_unlink, | |
53 | .mkdir = smb_mkdir, | |
54 | .rmdir = smb_rmdir, | |
55 | .rename = smb_rename, | |
56 | .getattr = smb_getattr, | |
57 | .setattr = smb_notify_change, | |
58 | }; | |
59 | ||
c5ef1c42 | 60 | const struct inode_operations smb_dir_inode_operations_unix = |
1da177e4 LT |
61 | { |
62 | .create = smb_create, | |
63 | .lookup = smb_lookup, | |
64 | .unlink = smb_unlink, | |
65 | .mkdir = smb_mkdir, | |
66 | .rmdir = smb_rmdir, | |
67 | .rename = smb_rename, | |
68 | .getattr = smb_getattr, | |
69 | .setattr = smb_notify_change, | |
70 | .symlink = smb_symlink, | |
71 | .mknod = smb_make_node, | |
72 | .link = smb_link, | |
73 | }; | |
74 | ||
75 | /* | |
76 | * Read a directory, using filldir to fill the dirent memory. | |
77 | * smb_proc_readdir does the actual reading from the smb server. | |
78 | * | |
79 | * The cache code is almost directly taken from ncpfs | |
80 | */ | |
81 | static int | |
82 | smb_readdir(struct file *filp, void *dirent, filldir_t filldir) | |
83 | { | |
17b75e69 | 84 | struct dentry *dentry = filp->f_path.dentry; |
1da177e4 LT |
85 | struct inode *dir = dentry->d_inode; |
86 | struct smb_sb_info *server = server_from_dentry(dentry); | |
87 | union smb_dir_cache *cache = NULL; | |
88 | struct smb_cache_control ctl; | |
89 | struct page *page = NULL; | |
90 | int result; | |
91 | ||
92 | ctl.page = NULL; | |
93 | ctl.cache = NULL; | |
94 | ||
95 | VERBOSE("reading %s/%s, f_pos=%d\n", | |
96 | DENTRY_PATH(dentry), (int) filp->f_pos); | |
97 | ||
98 | result = 0; | |
99 | ||
100 | lock_kernel(); | |
101 | ||
102 | switch ((unsigned int) filp->f_pos) { | |
103 | case 0: | |
104 | if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0) | |
105 | goto out; | |
106 | filp->f_pos = 1; | |
107 | /* fallthrough */ | |
108 | case 1: | |
109 | if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0) | |
110 | goto out; | |
111 | filp->f_pos = 2; | |
112 | } | |
113 | ||
114 | /* | |
115 | * Make sure our inode is up-to-date. | |
116 | */ | |
117 | result = smb_revalidate_inode(dentry); | |
118 | if (result) | |
119 | goto out; | |
120 | ||
121 | ||
122 | page = grab_cache_page(&dir->i_data, 0); | |
123 | if (!page) | |
124 | goto read_really; | |
125 | ||
126 | ctl.cache = cache = kmap(page); | |
127 | ctl.head = cache->head; | |
128 | ||
129 | if (!PageUptodate(page) || !ctl.head.eof) { | |
130 | VERBOSE("%s/%s, page uptodate=%d, eof=%d\n", | |
131 | DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof); | |
132 | goto init_cache; | |
133 | } | |
134 | ||
135 | if (filp->f_pos == 2) { | |
136 | if (jiffies - ctl.head.time >= SMB_MAX_AGE(server)) | |
137 | goto init_cache; | |
138 | ||
139 | /* | |
140 | * N.B. ncpfs checks mtime of dentry too here, we don't. | |
141 | * 1. common smb servers do not update mtime on dir changes | |
142 | * 2. it requires an extra smb request | |
143 | * (revalidate has the same timeout as ctl.head.time) | |
144 | * | |
145 | * Instead smbfs invalidates its own cache on local changes | |
146 | * and remote changes are not seen until timeout. | |
147 | */ | |
148 | } | |
149 | ||
150 | if (filp->f_pos > ctl.head.end) | |
151 | goto finished; | |
152 | ||
153 | ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2); | |
154 | ctl.ofs = ctl.fpos / SMB_DIRCACHE_SIZE; | |
155 | ctl.idx = ctl.fpos % SMB_DIRCACHE_SIZE; | |
156 | ||
157 | for (;;) { | |
158 | if (ctl.ofs != 0) { | |
159 | ctl.page = find_lock_page(&dir->i_data, ctl.ofs); | |
160 | if (!ctl.page) | |
161 | goto invalid_cache; | |
162 | ctl.cache = kmap(ctl.page); | |
163 | if (!PageUptodate(ctl.page)) | |
164 | goto invalid_cache; | |
165 | } | |
166 | while (ctl.idx < SMB_DIRCACHE_SIZE) { | |
167 | struct dentry *dent; | |
168 | int res; | |
169 | ||
170 | dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx], | |
171 | dentry, filp->f_pos); | |
172 | if (!dent) | |
173 | goto invalid_cache; | |
174 | ||
175 | res = filldir(dirent, dent->d_name.name, | |
176 | dent->d_name.len, filp->f_pos, | |
177 | dent->d_inode->i_ino, DT_UNKNOWN); | |
178 | dput(dent); | |
179 | if (res) | |
180 | goto finished; | |
181 | filp->f_pos += 1; | |
182 | ctl.idx += 1; | |
183 | if (filp->f_pos > ctl.head.end) | |
184 | goto finished; | |
185 | } | |
186 | if (ctl.page) { | |
187 | kunmap(ctl.page); | |
188 | SetPageUptodate(ctl.page); | |
189 | unlock_page(ctl.page); | |
190 | page_cache_release(ctl.page); | |
191 | ctl.page = NULL; | |
192 | } | |
193 | ctl.idx = 0; | |
194 | ctl.ofs += 1; | |
195 | } | |
196 | invalid_cache: | |
197 | if (ctl.page) { | |
198 | kunmap(ctl.page); | |
199 | unlock_page(ctl.page); | |
200 | page_cache_release(ctl.page); | |
201 | ctl.page = NULL; | |
202 | } | |
203 | ctl.cache = cache; | |
204 | init_cache: | |
205 | smb_invalidate_dircache_entries(dentry); | |
206 | ctl.head.time = jiffies; | |
207 | ctl.head.eof = 0; | |
208 | ctl.fpos = 2; | |
209 | ctl.ofs = 0; | |
210 | ctl.idx = SMB_DIRCACHE_START; | |
211 | ctl.filled = 0; | |
212 | ctl.valid = 1; | |
213 | read_really: | |
214 | result = server->ops->readdir(filp, dirent, filldir, &ctl); | |
caf73608 AM |
215 | if (result == -ERESTARTSYS && page) |
216 | ClearPageUptodate(page); | |
1da177e4 LT |
217 | if (ctl.idx == -1) |
218 | goto invalid_cache; /* retry */ | |
219 | ctl.head.end = ctl.fpos - 1; | |
220 | ctl.head.eof = ctl.valid; | |
221 | finished: | |
222 | if (page) { | |
223 | cache->head = ctl.head; | |
224 | kunmap(page); | |
caf73608 AM |
225 | if (result != -ERESTARTSYS) |
226 | SetPageUptodate(page); | |
1da177e4 LT |
227 | unlock_page(page); |
228 | page_cache_release(page); | |
229 | } | |
230 | if (ctl.page) { | |
231 | kunmap(ctl.page); | |
232 | SetPageUptodate(ctl.page); | |
233 | unlock_page(ctl.page); | |
234 | page_cache_release(ctl.page); | |
235 | } | |
236 | out: | |
237 | unlock_kernel(); | |
238 | return result; | |
239 | } | |
240 | ||
241 | static int | |
242 | smb_dir_open(struct inode *dir, struct file *file) | |
243 | { | |
17b75e69 | 244 | struct dentry *dentry = file->f_path.dentry; |
1da177e4 LT |
245 | struct smb_sb_info *server; |
246 | int error = 0; | |
247 | ||
248 | VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name, | |
17b75e69 | 249 | file->f_path.dentry->d_name.name); |
1da177e4 LT |
250 | |
251 | /* | |
252 | * Directory timestamps in the core protocol aren't updated | |
253 | * when a file is added, so we give them a very short TTL. | |
254 | */ | |
255 | lock_kernel(); | |
256 | server = server_from_dentry(dentry); | |
257 | if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) { | |
258 | unsigned long age = jiffies - SMB_I(dir)->oldmtime; | |
259 | if (age > 2*HZ) | |
260 | smb_invalid_dir_cache(dir); | |
261 | } | |
262 | ||
263 | /* | |
264 | * Note: in order to allow the smbmount process to open the | |
265 | * mount point, we only revalidate if the connection is valid or | |
266 | * if the process is trying to access something other than the root. | |
267 | */ | |
268 | if (server->state == CONN_VALID || !IS_ROOT(dentry)) | |
269 | error = smb_revalidate_inode(dentry); | |
270 | unlock_kernel(); | |
271 | return error; | |
272 | } | |
273 | ||
274 | /* | |
275 | * Dentry operations routines | |
276 | */ | |
277 | static int smb_lookup_validate(struct dentry *, struct nameidata *); | |
b1e6a015 NP |
278 | static int smb_hash_dentry(const struct dentry *, const struct inode *, |
279 | struct qstr *); | |
621e155a NP |
280 | static int smb_compare_dentry(const struct dentry *, |
281 | const struct inode *, | |
282 | const struct dentry *, const struct inode *, | |
283 | unsigned int, const char *, const struct qstr *); | |
fe15ce44 | 284 | static int smb_delete_dentry(const struct dentry *); |
1da177e4 | 285 | |
e16404ed | 286 | static const struct dentry_operations smbfs_dentry_operations = |
1da177e4 LT |
287 | { |
288 | .d_revalidate = smb_lookup_validate, | |
289 | .d_hash = smb_hash_dentry, | |
290 | .d_compare = smb_compare_dentry, | |
291 | .d_delete = smb_delete_dentry, | |
292 | }; | |
293 | ||
e16404ed | 294 | static const struct dentry_operations smbfs_dentry_operations_case = |
1da177e4 LT |
295 | { |
296 | .d_revalidate = smb_lookup_validate, | |
297 | .d_delete = smb_delete_dentry, | |
298 | }; | |
299 | ||
300 | ||
301 | /* | |
302 | * This is the callback when the dcache has a lookup hit. | |
303 | */ | |
304 | static int | |
34286d66 | 305 | smb_lookup_validate(struct dentry *dentry, struct nameidata *nd) |
1da177e4 | 306 | { |
34286d66 NP |
307 | struct smb_sb_info *server; |
308 | struct inode *inode; | |
309 | unsigned long age; | |
1da177e4 LT |
310 | int valid; |
311 | ||
34286d66 NP |
312 | if (nd->flags & LOOKUP_RCU) |
313 | return -ECHILD; | |
314 | ||
315 | server = server_from_dentry(dentry); | |
316 | inode = dentry->d_inode; | |
317 | age = jiffies - dentry->d_time; | |
318 | ||
1da177e4 LT |
319 | /* |
320 | * The default validation is based on dentry age: | |
321 | * we believe in dentries for a few seconds. (But each | |
322 | * successful server lookup renews the timestamp.) | |
323 | */ | |
324 | valid = (age <= SMB_MAX_AGE(server)); | |
325 | #ifdef SMBFS_DEBUG_VERBOSE | |
326 | if (!valid) | |
327 | VERBOSE("%s/%s not valid, age=%lu\n", | |
328 | DENTRY_PATH(dentry), age); | |
329 | #endif | |
330 | ||
331 | if (inode) { | |
332 | lock_kernel(); | |
333 | if (is_bad_inode(inode)) { | |
334 | PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry)); | |
335 | valid = 0; | |
336 | } else if (!valid) | |
337 | valid = (smb_revalidate_inode(dentry) == 0); | |
338 | unlock_kernel(); | |
339 | } else { | |
340 | /* | |
341 | * What should we do for negative dentries? | |
342 | */ | |
343 | } | |
344 | return valid; | |
345 | } | |
346 | ||
347 | static int | |
b1e6a015 NP |
348 | smb_hash_dentry(const struct dentry *dir, const struct inode *inode, |
349 | struct qstr *this) | |
1da177e4 LT |
350 | { |
351 | unsigned long hash; | |
352 | int i; | |
353 | ||
354 | hash = init_name_hash(); | |
355 | for (i=0; i < this->len ; i++) | |
356 | hash = partial_name_hash(tolower(this->name[i]), hash); | |
357 | this->hash = end_name_hash(hash); | |
358 | ||
359 | return 0; | |
360 | } | |
361 | ||
362 | static int | |
621e155a NP |
363 | smb_compare_dentry(const struct dentry *parent, |
364 | const struct inode *pinode, | |
365 | const struct dentry *dentry, const struct inode *inode, | |
366 | unsigned int len, const char *str, const struct qstr *name) | |
1da177e4 LT |
367 | { |
368 | int i, result = 1; | |
369 | ||
621e155a | 370 | if (len != name->len) |
1da177e4 | 371 | goto out; |
621e155a NP |
372 | for (i=0; i < len; i++) { |
373 | if (tolower(str[i]) != tolower(name->name[i])) | |
1da177e4 LT |
374 | goto out; |
375 | } | |
376 | result = 0; | |
377 | out: | |
378 | return result; | |
379 | } | |
380 | ||
381 | /* | |
382 | * This is the callback from dput() when d_count is going to 0. | |
383 | * We use this to unhash dentries with bad inodes. | |
384 | */ | |
385 | static int | |
fe15ce44 | 386 | smb_delete_dentry(const struct dentry *dentry) |
1da177e4 LT |
387 | { |
388 | if (dentry->d_inode) { | |
389 | if (is_bad_inode(dentry->d_inode)) { | |
390 | PARANOIA("bad inode, unhashing %s/%s\n", | |
391 | DENTRY_PATH(dentry)); | |
392 | return 1; | |
393 | } | |
394 | } else { | |
395 | /* N.B. Unhash negative dentries? */ | |
396 | } | |
397 | return 0; | |
398 | } | |
399 | ||
400 | /* | |
401 | * Initialize a new dentry | |
402 | */ | |
403 | void | |
404 | smb_new_dentry(struct dentry *dentry) | |
405 | { | |
406 | struct smb_sb_info *server = server_from_dentry(dentry); | |
407 | ||
408 | if (server->mnt->flags & SMB_MOUNT_CASE) | |
fb045adb | 409 | d_set_d_op(dentry, &smbfs_dentry_operations_case); |
1da177e4 | 410 | else |
fb045adb | 411 | d_set_d_op(dentry, &smbfs_dentry_operations); |
1da177e4 LT |
412 | dentry->d_time = jiffies; |
413 | } | |
414 | ||
415 | ||
416 | /* | |
417 | * Whenever a lookup succeeds, we know the parent directories | |
418 | * are all valid, so we want to update the dentry timestamps. | |
419 | * N.B. Move this to dcache? | |
420 | */ | |
421 | void | |
422 | smb_renew_times(struct dentry * dentry) | |
423 | { | |
424 | dget(dentry); | |
be9eee2e | 425 | dentry->d_time = jiffies; |
1da177e4 | 426 | |
be9eee2e CH |
427 | while (!IS_ROOT(dentry)) { |
428 | struct dentry *parent = dget_parent(dentry); | |
1da177e4 LT |
429 | dput(dentry); |
430 | dentry = parent; | |
be9eee2e CH |
431 | |
432 | dentry->d_time = jiffies; | |
1da177e4 | 433 | } |
1da177e4 LT |
434 | dput(dentry); |
435 | } | |
436 | ||
437 | static struct dentry * | |
438 | smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) | |
439 | { | |
440 | struct smb_fattr finfo; | |
441 | struct inode *inode; | |
442 | int error; | |
443 | struct smb_sb_info *server; | |
444 | ||
445 | error = -ENAMETOOLONG; | |
446 | if (dentry->d_name.len > SMB_MAXNAMELEN) | |
447 | goto out; | |
448 | ||
3b7c8108 OK |
449 | /* Do not allow lookup of names with backslashes in */ |
450 | error = -EINVAL; | |
451 | if (memchr(dentry->d_name.name, '\\', dentry->d_name.len)) | |
452 | goto out; | |
453 | ||
1da177e4 LT |
454 | lock_kernel(); |
455 | error = smb_proc_getattr(dentry, &finfo); | |
456 | #ifdef SMBFS_PARANOIA | |
457 | if (error && error != -ENOENT) | |
458 | PARANOIA("find %s/%s failed, error=%d\n", | |
459 | DENTRY_PATH(dentry), error); | |
460 | #endif | |
461 | ||
462 | inode = NULL; | |
463 | if (error == -ENOENT) | |
464 | goto add_entry; | |
465 | if (!error) { | |
466 | error = -EACCES; | |
467 | finfo.f_ino = iunique(dentry->d_sb, 2); | |
468 | inode = smb_iget(dir->i_sb, &finfo); | |
469 | if (inode) { | |
470 | add_entry: | |
471 | server = server_from_dentry(dentry); | |
472 | if (server->mnt->flags & SMB_MOUNT_CASE) | |
fb045adb | 473 | d_set_d_op(dentry, &smbfs_dentry_operations_case); |
1da177e4 | 474 | else |
fb045adb | 475 | d_set_d_op(dentry, &smbfs_dentry_operations); |
1da177e4 LT |
476 | |
477 | d_add(dentry, inode); | |
478 | smb_renew_times(dentry); | |
479 | error = 0; | |
480 | } | |
481 | } | |
482 | unlock_kernel(); | |
483 | out: | |
484 | return ERR_PTR(error); | |
485 | } | |
486 | ||
487 | /* | |
488 | * This code is common to all routines creating a new inode. | |
489 | */ | |
490 | static int | |
491 | smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id) | |
492 | { | |
493 | struct smb_sb_info *server = server_from_dentry(dentry); | |
494 | struct inode *inode; | |
495 | int error; | |
496 | struct smb_fattr fattr; | |
497 | ||
498 | VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid); | |
499 | ||
500 | error = smb_proc_getattr(dentry, &fattr); | |
501 | if (error) | |
502 | goto out_close; | |
503 | ||
504 | smb_renew_times(dentry); | |
505 | fattr.f_ino = iunique(dentry->d_sb, 2); | |
506 | inode = smb_iget(dentry->d_sb, &fattr); | |
507 | if (!inode) | |
508 | goto out_no_inode; | |
509 | ||
510 | if (have_id) { | |
511 | struct smb_inode_info *ei = SMB_I(inode); | |
512 | ei->fileid = fileid; | |
513 | ei->access = SMB_O_RDWR; | |
514 | ei->open = server->generation; | |
515 | } | |
516 | d_instantiate(dentry, inode); | |
517 | out: | |
518 | return error; | |
519 | ||
520 | out_no_inode: | |
521 | error = -EACCES; | |
522 | out_close: | |
523 | if (have_id) { | |
524 | PARANOIA("%s/%s failed, error=%d, closing %u\n", | |
525 | DENTRY_PATH(dentry), error, fileid); | |
526 | smb_close_fileid(dentry, fileid); | |
527 | } | |
528 | goto out; | |
529 | } | |
530 | ||
531 | /* N.B. How should the mode argument be used? */ | |
532 | static int | |
533 | smb_create(struct inode *dir, struct dentry *dentry, int mode, | |
534 | struct nameidata *nd) | |
535 | { | |
536 | struct smb_sb_info *server = server_from_dentry(dentry); | |
537 | __u16 fileid; | |
538 | int error; | |
539 | struct iattr attr; | |
540 | ||
541 | VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode); | |
542 | ||
543 | lock_kernel(); | |
544 | smb_invalid_dir_cache(dir); | |
545 | error = smb_proc_create(dentry, 0, get_seconds(), &fileid); | |
546 | if (!error) { | |
547 | if (server->opt.capabilities & SMB_CAP_UNIX) { | |
548 | /* Set attributes for new file */ | |
549 | attr.ia_valid = ATTR_MODE; | |
550 | attr.ia_mode = mode; | |
551 | error = smb_proc_setattr_unix(dentry, &attr, 0, 0); | |
552 | } | |
553 | error = smb_instantiate(dentry, fileid, 1); | |
554 | } else { | |
555 | PARANOIA("%s/%s failed, error=%d\n", | |
556 | DENTRY_PATH(dentry), error); | |
557 | } | |
558 | unlock_kernel(); | |
559 | return error; | |
560 | } | |
561 | ||
562 | /* N.B. How should the mode argument be used? */ | |
563 | static int | |
564 | smb_mkdir(struct inode *dir, struct dentry *dentry, int mode) | |
565 | { | |
566 | struct smb_sb_info *server = server_from_dentry(dentry); | |
567 | int error; | |
568 | struct iattr attr; | |
569 | ||
570 | lock_kernel(); | |
571 | smb_invalid_dir_cache(dir); | |
572 | error = smb_proc_mkdir(dentry); | |
573 | if (!error) { | |
574 | if (server->opt.capabilities & SMB_CAP_UNIX) { | |
575 | /* Set attributes for new directory */ | |
576 | attr.ia_valid = ATTR_MODE; | |
577 | attr.ia_mode = mode; | |
578 | error = smb_proc_setattr_unix(dentry, &attr, 0, 0); | |
579 | } | |
580 | error = smb_instantiate(dentry, 0, 0); | |
581 | } | |
582 | unlock_kernel(); | |
583 | return error; | |
584 | } | |
585 | ||
586 | static int | |
587 | smb_rmdir(struct inode *dir, struct dentry *dentry) | |
588 | { | |
589 | struct inode *inode = dentry->d_inode; | |
590 | int error; | |
591 | ||
592 | /* | |
593 | * Close the directory if it's open. | |
594 | */ | |
595 | lock_kernel(); | |
596 | smb_close(inode); | |
597 | ||
598 | /* | |
599 | * Check that nobody else is using the directory.. | |
600 | */ | |
601 | error = -EBUSY; | |
602 | if (!d_unhashed(dentry)) | |
603 | goto out; | |
604 | ||
605 | smb_invalid_dir_cache(dir); | |
606 | error = smb_proc_rmdir(dentry); | |
607 | ||
608 | out: | |
609 | unlock_kernel(); | |
610 | return error; | |
611 | } | |
612 | ||
613 | static int | |
614 | smb_unlink(struct inode *dir, struct dentry *dentry) | |
615 | { | |
616 | int error; | |
617 | ||
618 | /* | |
619 | * Close the file if it's open. | |
620 | */ | |
621 | lock_kernel(); | |
622 | smb_close(dentry->d_inode); | |
623 | ||
624 | smb_invalid_dir_cache(dir); | |
625 | error = smb_proc_unlink(dentry); | |
626 | if (!error) | |
627 | smb_renew_times(dentry); | |
628 | unlock_kernel(); | |
629 | return error; | |
630 | } | |
631 | ||
632 | static int | |
633 | smb_rename(struct inode *old_dir, struct dentry *old_dentry, | |
634 | struct inode *new_dir, struct dentry *new_dentry) | |
635 | { | |
636 | int error; | |
637 | ||
638 | /* | |
639 | * Close any open files, and check whether to delete the | |
640 | * target before attempting the rename. | |
641 | */ | |
642 | lock_kernel(); | |
643 | if (old_dentry->d_inode) | |
644 | smb_close(old_dentry->d_inode); | |
645 | if (new_dentry->d_inode) { | |
646 | smb_close(new_dentry->d_inode); | |
647 | error = smb_proc_unlink(new_dentry); | |
648 | if (error) { | |
649 | VERBOSE("unlink %s/%s, error=%d\n", | |
650 | DENTRY_PATH(new_dentry), error); | |
651 | goto out; | |
652 | } | |
653 | /* FIXME */ | |
654 | d_delete(new_dentry); | |
655 | } | |
656 | ||
657 | smb_invalid_dir_cache(old_dir); | |
658 | smb_invalid_dir_cache(new_dir); | |
659 | error = smb_proc_mv(old_dentry, new_dentry); | |
660 | if (!error) { | |
661 | smb_renew_times(old_dentry); | |
662 | smb_renew_times(new_dentry); | |
663 | } | |
664 | out: | |
665 | unlock_kernel(); | |
666 | return error; | |
667 | } | |
668 | ||
669 | /* | |
670 | * FIXME: samba servers won't let you create device nodes unless uid/gid | |
671 | * matches the connection credentials (and we don't know which those are ...) | |
672 | */ | |
673 | static int | |
674 | smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) | |
675 | { | |
676 | int error; | |
677 | struct iattr attr; | |
678 | ||
679 | attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID; | |
680 | attr.ia_mode = mode; | |
86a264ab | 681 | current_euid_egid(&attr.ia_uid, &attr.ia_gid); |
1da177e4 LT |
682 | |
683 | if (!new_valid_dev(dev)) | |
684 | return -EINVAL; | |
685 | ||
686 | smb_invalid_dir_cache(dir); | |
687 | error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev)); | |
688 | if (!error) { | |
689 | error = smb_instantiate(dentry, 0, 0); | |
690 | } | |
691 | return error; | |
692 | } | |
693 | ||
694 | /* | |
695 | * dentry = existing file | |
696 | * new_dentry = new file | |
697 | */ | |
698 | static int | |
699 | smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry) | |
700 | { | |
701 | int error; | |
702 | ||
703 | DEBUG1("smb_link old=%s/%s new=%s/%s\n", | |
704 | DENTRY_PATH(dentry), DENTRY_PATH(new_dentry)); | |
705 | smb_invalid_dir_cache(dir); | |
706 | error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry); | |
707 | if (!error) { | |
708 | smb_renew_times(dentry); | |
709 | error = smb_instantiate(new_dentry, 0, 0); | |
710 | } | |
711 | return error; | |
712 | } |