1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Contains mounting routines used for handling traversal via SMB junctions. 4 * 5 * Copyright (c) 2007 Igor Mammedov 6 * Copyright (C) International Business Machines Corp., 2008 7 * Author(s): Igor Mammedov (niallain@gmail.com) 8 * Steve French (sfrench@us.ibm.com) 9 * Copyright (c) 2023 Paulo Alcantara <palcantara@suse.de> 10 */ 11 12 #include <linux/dcache.h> 13 #include <linux/mount.h> 14 #include <linux/namei.h> 15 #include <linux/slab.h> 16 #include <linux/vfs.h> 17 #include <linux/fs.h> 18 #include <linux/inet.h> 19 #include "cifsglob.h" 20 #include "cifsproto.h" 21 #include "cifsfs.h" 22 #include "cifs_debug.h" 23 #include "fs_context.h" 24 25 static LIST_HEAD(cifs_automount_list); 26 27 static void cifs_expire_automounts(struct work_struct *work); 28 static DECLARE_DELAYED_WORK(cifs_automount_task, 29 cifs_expire_automounts); 30 static int cifs_mountpoint_expiry_timeout = 500 * HZ; 31 32 static void cifs_expire_automounts(struct work_struct *work) 33 { 34 struct list_head *list = &cifs_automount_list; 35 36 mark_mounts_for_expiry(list); 37 if (!list_empty(list)) 38 schedule_delayed_work(&cifs_automount_task, 39 cifs_mountpoint_expiry_timeout); 40 } 41 42 void cifs_release_automount_timer(void) 43 { 44 if (WARN_ON(!list_empty(&cifs_automount_list))) 45 return; 46 cancel_delayed_work_sync(&cifs_automount_task); 47 } 48 49 /** 50 * cifs_build_devname - build a devicename from a UNC and optional prepath 51 * @nodename: pointer to UNC string 52 * @prepath: pointer to prefixpath (or NULL if there isn't one) 53 * 54 * Build a new cifs devicename after chasing a DFS referral. Allocate a buffer 55 * big enough to hold the final thing. Copy the UNC from the nodename, and 56 * concatenate the prepath onto the end of it if there is one. 57 * 58 * Returns pointer to the built string, or a ERR_PTR. Caller is responsible 59 * for freeing the returned string. 60 */ 61 char * 62 cifs_build_devname(char *nodename, const char *prepath) 63 { 64 size_t pplen; 65 size_t unclen; 66 char *dev; 67 char *pos; 68 69 /* skip over any preceding delimiters */ 70 nodename += strspn(nodename, "\\"); 71 if (!*nodename) 72 return ERR_PTR(-EINVAL); 73 74 /* get length of UNC and set pos to last char */ 75 unclen = strlen(nodename); 76 pos = nodename + unclen - 1; 77 78 /* trim off any trailing delimiters */ 79 while (*pos == '\\') { 80 --pos; 81 --unclen; 82 } 83 84 /* allocate a buffer: 85 * +2 for preceding "//" 86 * +1 for delimiter between UNC and prepath 87 * +1 for trailing NULL 88 */ 89 pplen = prepath ? strlen(prepath) : 0; 90 dev = kmalloc(2 + unclen + 1 + pplen + 1, GFP_KERNEL); 91 if (!dev) 92 return ERR_PTR(-ENOMEM); 93 94 pos = dev; 95 /* add the initial "//" */ 96 *pos = '/'; 97 ++pos; 98 *pos = '/'; 99 ++pos; 100 101 /* copy in the UNC portion from referral */ 102 memcpy(pos, nodename, unclen); 103 pos += unclen; 104 105 /* copy the prefixpath remainder (if there is one) */ 106 if (pplen) { 107 *pos = '/'; 108 ++pos; 109 memcpy(pos, prepath, pplen); 110 pos += pplen; 111 } 112 113 /* NULL terminator */ 114 *pos = '\0'; 115 116 convert_delimiter(dev, '/'); 117 return dev; 118 } 119 120 static bool is_dfs_mount(struct dentry *dentry) 121 { 122 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb); 123 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 124 bool ret; 125 126 spin_lock(&tcon->tc_lock); 127 ret = !!tcon->origin_fullpath; 128 spin_unlock(&tcon->tc_lock); 129 return ret; 130 } 131 132 /* Return full path out of a dentry set for automount */ 133 static char *automount_fullpath(struct dentry *dentry, void *page) 134 { 135 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb); 136 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 137 size_t len; 138 char *s; 139 140 spin_lock(&tcon->tc_lock); 141 if (!tcon->origin_fullpath) { 142 spin_unlock(&tcon->tc_lock); 143 return build_path_from_dentry_optional_prefix(dentry, 144 page, 145 true); 146 } 147 spin_unlock(&tcon->tc_lock); 148 149 s = dentry_path_raw(dentry, page, PATH_MAX); 150 if (IS_ERR(s)) 151 return s; 152 /* for root, we want "" */ 153 if (!s[1]) 154 s++; 155 156 spin_lock(&tcon->tc_lock); 157 len = strlen(tcon->origin_fullpath); 158 if (s < (char *)page + len) { 159 spin_unlock(&tcon->tc_lock); 160 return ERR_PTR(-ENAMETOOLONG); 161 } 162 163 s -= len; 164 memcpy(s, tcon->origin_fullpath, len); 165 spin_unlock(&tcon->tc_lock); 166 convert_delimiter(s, '/'); 167 168 return s; 169 } 170 171 static void fs_context_set_ids(struct smb3_fs_context *ctx) 172 { 173 kuid_t uid = current_fsuid(); 174 kgid_t gid = current_fsgid(); 175 176 if (ctx->multiuser) { 177 if (!ctx->uid_specified) 178 ctx->linux_uid = uid; 179 if (!ctx->gid_specified) 180 ctx->linux_gid = gid; 181 } 182 if (!ctx->cruid_specified) 183 ctx->cred_uid = uid; 184 } 185 186 /* 187 * Create a vfsmount that we can automount 188 */ 189 static struct vfsmount *cifs_do_automount(struct path *path) 190 { 191 int rc; 192 struct dentry *mntpt = path->dentry; 193 struct fs_context *fc; 194 void *page = NULL; 195 struct smb3_fs_context *ctx, *cur_ctx; 196 struct smb3_fs_context tmp; 197 char *full_path; 198 struct vfsmount *mnt; 199 struct cifs_sb_info *mntpt_sb; 200 struct cifs_ses *ses; 201 202 if (IS_ROOT(mntpt)) 203 return ERR_PTR(-ESTALE); 204 205 mntpt_sb = CIFS_SB(mntpt->d_sb); 206 ses = cifs_sb_master_tcon(mntpt_sb)->ses; 207 cur_ctx = mntpt_sb->ctx; 208 209 /* 210 * At this point, the root session should be in the mntpt sb. We should 211 * bring the sb context passwords in sync with the root session's 212 * passwords. This would help prevent unnecessary retries and password 213 * swaps for automounts. 214 */ 215 mutex_lock(&ses->session_mutex); 216 rc = smb3_sync_session_ctx_passwords(mntpt_sb, ses); 217 mutex_unlock(&ses->session_mutex); 218 219 if (rc) 220 return ERR_PTR(rc); 221 222 fc = fs_context_for_submount(path->mnt->mnt_sb->s_type, mntpt); 223 if (IS_ERR(fc)) 224 return ERR_CAST(fc); 225 226 ctx = smb3_fc2context(fc); 227 228 page = alloc_dentry_path(); 229 full_path = automount_fullpath(mntpt, page); 230 if (IS_ERR(full_path)) { 231 mnt = ERR_CAST(full_path); 232 goto out; 233 } 234 235 tmp = *cur_ctx; 236 tmp.source = NULL; 237 tmp.leaf_fullpath = NULL; 238 tmp.UNC = tmp.prepath = NULL; 239 tmp.dfs_root_ses = NULL; 240 fs_context_set_ids(&tmp); 241 242 rc = smb3_fs_context_dup(ctx, &tmp); 243 if (rc) { 244 mnt = ERR_PTR(rc); 245 goto out; 246 } 247 248 rc = smb3_parse_devname(full_path, ctx); 249 if (rc) { 250 mnt = ERR_PTR(rc); 251 goto out; 252 } 253 254 ctx->source = smb3_fs_context_fullpath(ctx, '/'); 255 if (IS_ERR(ctx->source)) { 256 mnt = ERR_CAST(ctx->source); 257 ctx->source = NULL; 258 goto out; 259 } 260 ctx->dfs_automount = ctx->dfs_conn = is_dfs_mount(mntpt); 261 cifs_dbg(FYI, "%s: ctx: source=%s UNC=%s prepath=%s dfs_automount=%d\n", 262 __func__, ctx->source, ctx->UNC, ctx->prepath, ctx->dfs_automount); 263 264 mnt = fc_mount(fc); 265 out: 266 put_fs_context(fc); 267 free_dentry_path(page); 268 return mnt; 269 } 270 271 /* 272 * Attempt to automount the referral 273 */ 274 struct vfsmount *cifs_d_automount(struct path *path) 275 { 276 struct vfsmount *newmnt; 277 278 cifs_dbg(FYI, "%s: %pd\n", __func__, path->dentry); 279 280 newmnt = cifs_do_automount(path); 281 if (IS_ERR(newmnt)) { 282 cifs_dbg(FYI, "leaving %s [automount failed]\n" , __func__); 283 return newmnt; 284 } 285 286 mntget(newmnt); /* prevent immediate expiration */ 287 mnt_set_expiry(newmnt, &cifs_automount_list); 288 schedule_delayed_work(&cifs_automount_task, 289 cifs_mountpoint_expiry_timeout); 290 cifs_dbg(FYI, "leaving %s [ok]\n" , __func__); 291 return newmnt; 292 } 293 294 const struct inode_operations cifs_namespace_inode_operations = { 295 }; 296