1 // SPDX-License-Identifier: GPL-2.0
3 * Functions to handle the cached directory entries
5 * Copyright (c) 2022, Ronnie Sahlberg <lsahlber@redhat.com>
8 #include <linux/namei.h>
10 #include "cifsproto.h"
11 #include "cifs_debug.h"
12 #include "smb2proto.h"
13 #include "cached_dir.h"
15 static struct cached_fid
*init_cached_dir(const char *path
);
16 static void free_cached_dir(struct cached_fid
*cfid
);
17 static void smb2_close_cached_fid(struct kref
*ref
);
18 static void cfids_laundromat_worker(struct work_struct
*work
);
20 static struct cached_fid
*find_or_create_cached_dir(struct cached_fids
*cfids
,
23 __u32 max_cached_dirs
)
25 struct cached_fid
*cfid
;
27 spin_lock(&cfids
->cfid_list_lock
);
28 list_for_each_entry(cfid
, &cfids
->entries
, entry
) {
29 if (!strcmp(cfid
->path
, path
)) {
31 * If it doesn't have a lease it is either not yet
32 * fully cached or it may be in the process of
33 * being deleted due to a lease break.
35 if (!cfid
->time
|| !cfid
->has_lease
) {
36 spin_unlock(&cfids
->cfid_list_lock
);
39 kref_get(&cfid
->refcount
);
40 spin_unlock(&cfids
->cfid_list_lock
);
45 spin_unlock(&cfids
->cfid_list_lock
);
48 if (cfids
->num_entries
>= max_cached_dirs
) {
49 spin_unlock(&cfids
->cfid_list_lock
);
52 cfid
= init_cached_dir(path
);
54 spin_unlock(&cfids
->cfid_list_lock
);
59 list_add(&cfid
->entry
, &cfids
->entries
);
61 kref_get(&cfid
->refcount
);
62 spin_unlock(&cfids
->cfid_list_lock
);
66 static struct dentry
*
67 path_to_dentry(struct cifs_sb_info
*cifs_sb
, const char *path
)
69 struct dentry
*dentry
;
73 sep
= CIFS_DIR_SEP(cifs_sb
);
74 dentry
= dget(cifs_sb
->root
);
78 struct inode
*dir
= d_inode(dentry
);
81 if (!S_ISDIR(dir
->i_mode
)) {
83 dentry
= ERR_PTR(-ENOTDIR
);
94 while (*s
&& *s
!= sep
)
97 child
= lookup_positive_unlocked(p
, dentry
, s
- p
);
100 } while (!IS_ERR(dentry
));
104 static const char *path_no_prefix(struct cifs_sb_info
*cifs_sb
,
112 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
) &&
114 len
= strlen(cifs_sb
->prepath
) + 1;
115 if (unlikely(len
> strlen(path
)))
116 return ERR_PTR(-EINVAL
);
122 * Open the and cache a directory handle.
123 * If error then *cfid is not initialized.
125 int open_cached_dir(unsigned int xid
, struct cifs_tcon
*tcon
,
127 struct cifs_sb_info
*cifs_sb
,
128 bool lookup_only
, struct cached_fid
**ret_cfid
)
130 struct cifs_ses
*ses
;
131 struct TCP_Server_Info
*server
;
132 struct cifs_open_parms oparms
;
133 struct smb2_create_rsp
*o_rsp
= NULL
;
134 struct smb2_query_info_rsp
*qi_rsp
= NULL
;
136 struct smb_rqst rqst
[2];
137 struct kvec rsp_iov
[2];
138 struct kvec open_iov
[SMB2_CREATE_IOV_SIZE
];
139 struct kvec qi_iov
[1];
141 __le16
*utf16_path
= NULL
;
142 u8 oplock
= SMB2_OPLOCK_LEVEL_II
;
143 struct cifs_fid
*pfid
;
144 struct dentry
*dentry
= NULL
;
145 struct cached_fid
*cfid
;
146 struct cached_fids
*cfids
;
149 if (tcon
== NULL
|| tcon
->cfids
== NULL
|| tcon
->nohandlecache
||
150 is_smb1_server(tcon
->ses
->server
) || (dir_cache_timeout
== 0))
154 server
= ses
->server
;
157 if (!server
->ops
->new_lease_key
)
160 if (cifs_sb
->root
== NULL
)
163 utf16_path
= cifs_convert_path_to_utf16(path
, cifs_sb
);
167 cfid
= find_or_create_cached_dir(cfids
, path
, lookup_only
, tcon
->max_cached_dirs
);
173 * Return cached fid if it has a lease. Otherwise, it is either a new
174 * entry or laundromat worker removed it from @cfids->entries. Caller
175 * will put last reference if the latter.
177 spin_lock(&cfids
->cfid_list_lock
);
178 if (cfid
->has_lease
) {
179 spin_unlock(&cfids
->cfid_list_lock
);
184 spin_unlock(&cfids
->cfid_list_lock
);
187 * Skip any prefix paths in @path as lookup_positive_unlocked() ends up
188 * calling ->lookup() which already adds those through
189 * build_path_from_dentry(). Also, do it earlier as we might reconnect
190 * below when trying to send compounded request and then potentially
191 * having a different prefix path (e.g. after DFS failover).
193 npath
= path_no_prefix(cifs_sb
, path
);
200 dentry
= dget(cifs_sb
->root
);
202 dentry
= path_to_dentry(cifs_sb
, npath
);
203 if (IS_ERR(dentry
)) {
208 cfid
->dentry
= dentry
;
211 * We do not hold the lock for the open because in case
212 * SMB2_open needs to reconnect.
213 * This is safe because no other thread will be able to get a ref
214 * to the cfid until we have finished opening the file and (possibly)
217 if (smb3_encryption_required(tcon
))
218 flags
|= CIFS_TRANSFORM_REQ
;
221 server
->ops
->new_lease_key(pfid
);
223 memset(rqst
, 0, sizeof(rqst
));
224 resp_buftype
[0] = resp_buftype
[1] = CIFS_NO_BUFFER
;
225 memset(rsp_iov
, 0, sizeof(rsp_iov
));
228 memset(&open_iov
, 0, sizeof(open_iov
));
229 rqst
[0].rq_iov
= open_iov
;
230 rqst
[0].rq_nvec
= SMB2_CREATE_IOV_SIZE
;
232 oparms
= (struct cifs_open_parms
) {
235 .create_options
= cifs_create_options(cifs_sb
, CREATE_NOT_FILE
),
236 .desired_access
= FILE_READ_DATA
| FILE_READ_ATTRIBUTES
,
237 .disposition
= FILE_OPEN
,
241 rc
= SMB2_open_init(tcon
, server
,
242 &rqst
[0], &oplock
, &oparms
, utf16_path
);
245 smb2_set_next_command(tcon
, &rqst
[0]);
247 memset(&qi_iov
, 0, sizeof(qi_iov
));
248 rqst
[1].rq_iov
= qi_iov
;
251 rc
= SMB2_query_info_init(tcon
, server
,
252 &rqst
[1], COMPOUND_FID
,
253 COMPOUND_FID
, FILE_ALL_INFORMATION
,
255 sizeof(struct smb2_file_all_info
) +
256 PATH_MAX
* 2, 0, NULL
);
260 smb2_set_related(&rqst
[1]);
263 * Set @cfid->has_lease to true before sending out compounded request so
264 * its lease reference can be put in cached_dir_lease_break() due to a
265 * potential lease break right after the request is sent or while @cfid
266 * is still being cached. Concurrent processes won't be to use it yet
267 * due to @cfid->time being zero.
269 cfid
->has_lease
= true;
271 rc
= compound_send_recv(xid
, ses
, server
,
273 resp_buftype
, rsp_iov
);
275 if (rc
== -EREMCHG
) {
276 tcon
->need_reconnect
= true;
277 pr_warn_once("server share %s deleted\n",
283 cfid
->is_open
= true;
285 spin_lock(&cfids
->cfid_list_lock
);
287 o_rsp
= (struct smb2_create_rsp
*)rsp_iov
[0].iov_base
;
288 oparms
.fid
->persistent_fid
= o_rsp
->PersistentFileId
;
289 oparms
.fid
->volatile_fid
= o_rsp
->VolatileFileId
;
290 #ifdef CONFIG_CIFS_DEBUG2
291 oparms
.fid
->mid
= le64_to_cpu(o_rsp
->hdr
.MessageId
);
292 #endif /* CIFS_DEBUG2 */
295 if (o_rsp
->OplockLevel
!= SMB2_OPLOCK_LEVEL_LEASE
) {
296 spin_unlock(&cfids
->cfid_list_lock
);
301 rc
= smb2_parse_contexts(server
, rsp_iov
,
303 oparms
.fid
->lease_key
,
304 &oplock
, NULL
, NULL
);
306 spin_unlock(&cfids
->cfid_list_lock
);
311 if (!(oplock
& SMB2_LEASE_READ_CACHING_HE
)) {
312 spin_unlock(&cfids
->cfid_list_lock
);
315 qi_rsp
= (struct smb2_query_info_rsp
*)rsp_iov
[1].iov_base
;
316 if (le32_to_cpu(qi_rsp
->OutputBufferLength
) < sizeof(struct smb2_file_all_info
)) {
317 spin_unlock(&cfids
->cfid_list_lock
);
320 if (!smb2_validate_and_copy_iov(
321 le16_to_cpu(qi_rsp
->OutputBufferOffset
),
322 sizeof(struct smb2_file_all_info
),
323 &rsp_iov
[1], sizeof(struct smb2_file_all_info
),
324 (char *)&cfid
->file_all_info
))
325 cfid
->file_all_info_is_valid
= true;
327 cfid
->time
= jiffies
;
328 spin_unlock(&cfids
->cfid_list_lock
);
329 /* At this point the directory handle is fully cached */
333 SMB2_open_free(&rqst
[0]);
334 SMB2_query_info_free(&rqst
[1]);
335 free_rsp_buf(resp_buftype
[0], rsp_iov
[0].iov_base
);
336 free_rsp_buf(resp_buftype
[1], rsp_iov
[1].iov_base
);
338 spin_lock(&cfids
->cfid_list_lock
);
340 list_del(&cfid
->entry
);
341 cfid
->on_list
= false;
342 cfids
->num_entries
--;
344 if (cfid
->has_lease
) {
346 * We are guaranteed to have two references at this
347 * point. One for the caller and one for a potential
348 * lease. Release the Lease-ref so that the directory
349 * will be closed when the caller closes the cached
352 cfid
->has_lease
= false;
353 spin_unlock(&cfids
->cfid_list_lock
);
354 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
357 spin_unlock(&cfids
->cfid_list_lock
);
362 SMB2_close(0, cfid
->tcon
, cfid
->fid
.persistent_fid
,
363 cfid
->fid
.volatile_fid
);
364 free_cached_dir(cfid
);
367 atomic_inc(&tcon
->num_remote_opens
);
373 int open_cached_dir_by_dentry(struct cifs_tcon
*tcon
,
374 struct dentry
*dentry
,
375 struct cached_fid
**ret_cfid
)
377 struct cached_fid
*cfid
;
378 struct cached_fids
*cfids
= tcon
->cfids
;
383 spin_lock(&cfids
->cfid_list_lock
);
384 list_for_each_entry(cfid
, &cfids
->entries
, entry
) {
385 if (dentry
&& cfid
->dentry
== dentry
) {
386 cifs_dbg(FYI
, "found a cached root file handle by dentry\n");
387 kref_get(&cfid
->refcount
);
389 spin_unlock(&cfids
->cfid_list_lock
);
393 spin_unlock(&cfids
->cfid_list_lock
);
398 smb2_close_cached_fid(struct kref
*ref
)
400 struct cached_fid
*cfid
= container_of(ref
, struct cached_fid
,
403 spin_lock(&cfid
->cfids
->cfid_list_lock
);
405 list_del(&cfid
->entry
);
406 cfid
->on_list
= false;
407 cfid
->cfids
->num_entries
--;
409 spin_unlock(&cfid
->cfids
->cfid_list_lock
);
415 SMB2_close(0, cfid
->tcon
, cfid
->fid
.persistent_fid
,
416 cfid
->fid
.volatile_fid
);
417 atomic_dec(&cfid
->tcon
->num_remote_opens
);
420 free_cached_dir(cfid
);
423 void drop_cached_dir_by_name(const unsigned int xid
, struct cifs_tcon
*tcon
,
424 const char *name
, struct cifs_sb_info
*cifs_sb
)
426 struct cached_fid
*cfid
= NULL
;
429 rc
= open_cached_dir(xid
, tcon
, name
, cifs_sb
, true, &cfid
);
431 cifs_dbg(FYI
, "no cached dir found for rmdir(%s)\n", name
);
434 spin_lock(&cfid
->cfids
->cfid_list_lock
);
435 if (cfid
->has_lease
) {
436 cfid
->has_lease
= false;
437 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
439 spin_unlock(&cfid
->cfids
->cfid_list_lock
);
440 close_cached_dir(cfid
);
444 void close_cached_dir(struct cached_fid
*cfid
)
446 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
450 * Called from cifs_kill_sb when we unmount a share
452 void close_all_cached_dirs(struct cifs_sb_info
*cifs_sb
)
454 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
455 struct rb_node
*node
;
456 struct cached_fid
*cfid
;
457 struct cifs_tcon
*tcon
;
458 struct tcon_link
*tlink
;
459 struct cached_fids
*cfids
;
461 for (node
= rb_first(root
); node
; node
= rb_next(node
)) {
462 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
463 tcon
= tlink_tcon(tlink
);
469 list_for_each_entry(cfid
, &cfids
->entries
, entry
) {
477 * Invalidate all cached dirs when a TCON has been reset
478 * due to a session loss.
480 void invalidate_all_cached_dirs(struct cifs_tcon
*tcon
)
482 struct cached_fids
*cfids
= tcon
->cfids
;
483 struct cached_fid
*cfid
, *q
;
489 spin_lock(&cfids
->cfid_list_lock
);
490 list_for_each_entry_safe(cfid
, q
, &cfids
->entries
, entry
) {
491 list_move(&cfid
->entry
, &entry
);
492 cfids
->num_entries
--;
493 cfid
->is_open
= false;
494 cfid
->on_list
= false;
495 /* To prevent race with smb2_cached_lease_break() */
496 kref_get(&cfid
->refcount
);
498 spin_unlock(&cfids
->cfid_list_lock
);
500 list_for_each_entry_safe(cfid
, q
, &entry
, entry
) {
501 list_del(&cfid
->entry
);
502 cancel_work_sync(&cfid
->lease_break
);
503 if (cfid
->has_lease
) {
505 * We lease was never cancelled from the server so we
506 * need to drop the reference.
508 spin_lock(&cfids
->cfid_list_lock
);
509 cfid
->has_lease
= false;
510 spin_unlock(&cfids
->cfid_list_lock
);
511 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
513 /* Drop the extra reference opened above*/
514 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
519 smb2_cached_lease_break(struct work_struct
*work
)
521 struct cached_fid
*cfid
= container_of(work
,
522 struct cached_fid
, lease_break
);
524 spin_lock(&cfid
->cfids
->cfid_list_lock
);
525 cfid
->has_lease
= false;
526 spin_unlock(&cfid
->cfids
->cfid_list_lock
);
527 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
530 int cached_dir_lease_break(struct cifs_tcon
*tcon
, __u8 lease_key
[16])
532 struct cached_fids
*cfids
= tcon
->cfids
;
533 struct cached_fid
*cfid
;
538 spin_lock(&cfids
->cfid_list_lock
);
539 list_for_each_entry(cfid
, &cfids
->entries
, entry
) {
540 if (cfid
->has_lease
&&
543 SMB2_LEASE_KEY_SIZE
)) {
546 * We found a lease remove it from the list
547 * so no threads can access it.
549 list_del(&cfid
->entry
);
550 cfid
->on_list
= false;
551 cfids
->num_entries
--;
553 queue_work(cifsiod_wq
,
555 spin_unlock(&cfids
->cfid_list_lock
);
559 spin_unlock(&cfids
->cfid_list_lock
);
563 static struct cached_fid
*init_cached_dir(const char *path
)
565 struct cached_fid
*cfid
;
567 cfid
= kzalloc(sizeof(*cfid
), GFP_ATOMIC
);
570 cfid
->path
= kstrdup(path
, GFP_ATOMIC
);
576 INIT_WORK(&cfid
->lease_break
, smb2_cached_lease_break
);
577 INIT_LIST_HEAD(&cfid
->entry
);
578 INIT_LIST_HEAD(&cfid
->dirents
.entries
);
579 mutex_init(&cfid
->dirents
.de_mutex
);
580 spin_lock_init(&cfid
->fid_lock
);
581 kref_init(&cfid
->refcount
);
585 static void free_cached_dir(struct cached_fid
*cfid
)
587 struct cached_dirent
*dirent
, *q
;
593 * Delete all cached dirent names
595 list_for_each_entry_safe(dirent
, q
, &cfid
->dirents
.entries
, entry
) {
596 list_del(&dirent
->entry
);
606 static void cfids_laundromat_worker(struct work_struct
*work
)
608 struct cached_fids
*cfids
;
609 struct cached_fid
*cfid
, *q
;
612 cfids
= container_of(work
, struct cached_fids
, laundromat_work
.work
);
614 spin_lock(&cfids
->cfid_list_lock
);
615 list_for_each_entry_safe(cfid
, q
, &cfids
->entries
, entry
) {
617 time_after(jiffies
, cfid
->time
+ HZ
* dir_cache_timeout
)) {
618 cfid
->on_list
= false;
619 list_move(&cfid
->entry
, &entry
);
620 cfids
->num_entries
--;
621 /* To prevent race with smb2_cached_lease_break() */
622 kref_get(&cfid
->refcount
);
625 spin_unlock(&cfids
->cfid_list_lock
);
627 list_for_each_entry_safe(cfid
, q
, &entry
, entry
) {
628 list_del(&cfid
->entry
);
630 * Cancel and wait for the work to finish in case we are racing
633 cancel_work_sync(&cfid
->lease_break
);
634 if (cfid
->has_lease
) {
636 * Our lease has not yet been cancelled from the server
637 * so we need to drop the reference.
639 spin_lock(&cfids
->cfid_list_lock
);
640 cfid
->has_lease
= false;
641 spin_unlock(&cfids
->cfid_list_lock
);
642 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
644 /* Drop the extra reference opened above */
645 kref_put(&cfid
->refcount
, smb2_close_cached_fid
);
647 queue_delayed_work(cifsiod_wq
, &cfids
->laundromat_work
,
648 dir_cache_timeout
* HZ
);
651 struct cached_fids
*init_cached_dirs(void)
653 struct cached_fids
*cfids
;
655 cfids
= kzalloc(sizeof(*cfids
), GFP_KERNEL
);
658 spin_lock_init(&cfids
->cfid_list_lock
);
659 INIT_LIST_HEAD(&cfids
->entries
);
661 INIT_DELAYED_WORK(&cfids
->laundromat_work
, cfids_laundromat_worker
);
662 queue_delayed_work(cifsiod_wq
, &cfids
->laundromat_work
,
663 dir_cache_timeout
* HZ
);
669 * Called from tconInfoFree when we are tearing down the tcon.
670 * There are no active users or open files/directories at this point.
672 void free_cached_dirs(struct cached_fids
*cfids
)
674 struct cached_fid
*cfid
, *q
;
680 cancel_delayed_work_sync(&cfids
->laundromat_work
);
682 spin_lock(&cfids
->cfid_list_lock
);
683 list_for_each_entry_safe(cfid
, q
, &cfids
->entries
, entry
) {
684 cfid
->on_list
= false;
685 cfid
->is_open
= false;
686 list_move(&cfid
->entry
, &entry
);
688 spin_unlock(&cfids
->cfid_list_lock
);
690 list_for_each_entry_safe(cfid
, q
, &entry
, entry
) {
691 list_del(&cfid
->entry
);
692 free_cached_dir(cfid
);