1 /* mountpoint management 2 * 3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/fs.h> 16 #include <linux/pagemap.h> 17 #include <linux/mount.h> 18 #include <linux/namei.h> 19 #include <linux/gfp.h> 20 #include "internal.h" 21 22 23 static struct dentry *afs_mntpt_lookup(struct inode *dir, 24 struct dentry *dentry, 25 struct nameidata *nd); 26 static int afs_mntpt_open(struct inode *inode, struct file *file); 27 static void *afs_mntpt_follow_link(struct dentry *dentry, struct nameidata *nd); 28 static void afs_mntpt_expiry_timed_out(struct work_struct *work); 29 30 const struct file_operations afs_mntpt_file_operations = { 31 .open = afs_mntpt_open, 32 }; 33 34 const struct inode_operations afs_mntpt_inode_operations = { 35 .lookup = afs_mntpt_lookup, 36 .follow_link = afs_mntpt_follow_link, 37 .readlink = page_readlink, 38 .getattr = afs_getattr, 39 }; 40 41 const struct inode_operations afs_autocell_inode_operations = { 42 .follow_link = afs_mntpt_follow_link, 43 .getattr = afs_getattr, 44 }; 45 46 static LIST_HEAD(afs_vfsmounts); 47 static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out); 48 49 static unsigned long afs_mntpt_expiry_timeout = 10 * 60; 50 51 /* 52 * check a symbolic link to see whether it actually encodes a mountpoint 53 * - sets the AFS_VNODE_MOUNTPOINT flag on the vnode appropriately 54 */ 55 int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key) 56 { 57 struct page *page; 58 size_t size; 59 char *buf; 60 int ret; 61 62 _enter("{%x:%u,%u}", 63 vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); 64 65 /* read the contents of the symlink into the pagecache */ 66 page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0, 67 afs_page_filler, key); 68 if (IS_ERR(page)) { 69 ret = PTR_ERR(page); 70 goto out; 71 } 72 73 ret = -EIO; 74 if (PageError(page)) 75 goto out_free; 76 77 buf = kmap(page); 78 79 /* examine the symlink's contents */ 80 size = vnode->status.size; 81 _debug("symlink to %*.*s", (int) size, (int) size, buf); 82 83 if (size > 2 && 84 (buf[0] == '%' || buf[0] == '#') && 85 buf[size - 1] == '.' 86 ) { 87 _debug("symlink is a mountpoint"); 88 spin_lock(&vnode->lock); 89 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); 90 spin_unlock(&vnode->lock); 91 } 92 93 ret = 0; 94 95 kunmap(page); 96 out_free: 97 page_cache_release(page); 98 out: 99 _leave(" = %d", ret); 100 return ret; 101 } 102 103 /* 104 * no valid lookup procedure on this sort of dir 105 */ 106 static struct dentry *afs_mntpt_lookup(struct inode *dir, 107 struct dentry *dentry, 108 struct nameidata *nd) 109 { 110 _enter("%p,%p{%p{%s},%s}", 111 dir, 112 dentry, 113 dentry->d_parent, 114 dentry->d_parent ? 115 dentry->d_parent->d_name.name : (const unsigned char *) "", 116 dentry->d_name.name); 117 118 return ERR_PTR(-EREMOTE); 119 } 120 121 /* 122 * no valid open procedure on this sort of dir 123 */ 124 static int afs_mntpt_open(struct inode *inode, struct file *file) 125 { 126 _enter("%p,%p{%p{%s},%s}", 127 inode, file, 128 file->f_path.dentry->d_parent, 129 file->f_path.dentry->d_parent ? 130 file->f_path.dentry->d_parent->d_name.name : 131 (const unsigned char *) "", 132 file->f_path.dentry->d_name.name); 133 134 return -EREMOTE; 135 } 136 137 /* 138 * create a vfsmount to be automounted 139 */ 140 static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt) 141 { 142 struct afs_super_info *super; 143 struct vfsmount *mnt; 144 struct afs_vnode *vnode; 145 struct page *page; 146 char *devname, *options; 147 bool rwpath = false; 148 int ret; 149 150 _enter("{%s}", mntpt->d_name.name); 151 152 BUG_ON(!mntpt->d_inode); 153 154 ret = -ENOMEM; 155 devname = (char *) get_zeroed_page(GFP_KERNEL); 156 if (!devname) 157 goto error_no_devname; 158 159 options = (char *) get_zeroed_page(GFP_KERNEL); 160 if (!options) 161 goto error_no_options; 162 163 vnode = AFS_FS_I(mntpt->d_inode); 164 if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) { 165 /* if the directory is a pseudo directory, use the d_name */ 166 static const char afs_root_cell[] = ":root.cell."; 167 unsigned size = mntpt->d_name.len; 168 169 ret = -ENOENT; 170 if (size < 2 || size > AFS_MAXCELLNAME) 171 goto error_no_page; 172 173 if (mntpt->d_name.name[0] == '.') { 174 devname[0] = '#'; 175 memcpy(devname + 1, mntpt->d_name.name, size - 1); 176 memcpy(devname + size, afs_root_cell, 177 sizeof(afs_root_cell)); 178 rwpath = true; 179 } else { 180 devname[0] = '%'; 181 memcpy(devname + 1, mntpt->d_name.name, size); 182 memcpy(devname + size + 1, afs_root_cell, 183 sizeof(afs_root_cell)); 184 } 185 } else { 186 /* read the contents of the AFS special symlink */ 187 loff_t size = i_size_read(mntpt->d_inode); 188 char *buf; 189 190 ret = -EINVAL; 191 if (size > PAGE_SIZE - 1) 192 goto error_no_page; 193 194 page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL); 195 if (IS_ERR(page)) { 196 ret = PTR_ERR(page); 197 goto error_no_page; 198 } 199 200 ret = -EIO; 201 if (PageError(page)) 202 goto error; 203 204 buf = kmap_atomic(page, KM_USER0); 205 memcpy(devname, buf, size); 206 kunmap_atomic(buf, KM_USER0); 207 page_cache_release(page); 208 page = NULL; 209 } 210 211 /* work out what options we want */ 212 super = AFS_FS_S(mntpt->d_sb); 213 memcpy(options, "cell=", 5); 214 strcpy(options + 5, super->volume->cell->name); 215 if (super->volume->type == AFSVL_RWVOL || rwpath) 216 strcat(options, ",rwpath"); 217 218 /* try and do the mount */ 219 _debug("--- attempting mount %s -o %s ---", devname, options); 220 mnt = vfs_kern_mount(&afs_fs_type, 0, devname, options); 221 _debug("--- mount result %p ---", mnt); 222 223 free_page((unsigned long) devname); 224 free_page((unsigned long) options); 225 _leave(" = %p", mnt); 226 return mnt; 227 228 error: 229 page_cache_release(page); 230 error_no_page: 231 free_page((unsigned long) options); 232 error_no_options: 233 free_page((unsigned long) devname); 234 error_no_devname: 235 _leave(" = %d", ret); 236 return ERR_PTR(ret); 237 } 238 239 /* 240 * follow a link from a mountpoint directory, thus causing it to be mounted 241 */ 242 static void *afs_mntpt_follow_link(struct dentry *dentry, struct nameidata *nd) 243 { 244 struct vfsmount *newmnt; 245 int err; 246 247 _enter("%p{%s},{%s:%p{%s},}", 248 dentry, 249 dentry->d_name.name, 250 nd->path.mnt->mnt_devname, 251 dentry, 252 nd->path.dentry->d_name.name); 253 254 dput(nd->path.dentry); 255 nd->path.dentry = dget(dentry); 256 257 newmnt = afs_mntpt_do_automount(nd->path.dentry); 258 if (IS_ERR(newmnt)) { 259 path_put(&nd->path); 260 return (void *)newmnt; 261 } 262 263 mntget(newmnt); 264 err = do_add_mount(newmnt, &nd->path, MNT_SHRINKABLE, &afs_vfsmounts); 265 switch (err) { 266 case 0: 267 path_put(&nd->path); 268 nd->path.mnt = newmnt; 269 nd->path.dentry = dget(newmnt->mnt_root); 270 schedule_delayed_work(&afs_mntpt_expiry_timer, 271 afs_mntpt_expiry_timeout * HZ); 272 break; 273 case -EBUSY: 274 /* someone else made a mount here whilst we were busy */ 275 while (d_mountpoint(nd->path.dentry) && 276 follow_down(&nd->path)) 277 ; 278 err = 0; 279 default: 280 mntput(newmnt); 281 break; 282 } 283 284 _leave(" = %d", err); 285 return ERR_PTR(err); 286 } 287 288 /* 289 * handle mountpoint expiry timer going off 290 */ 291 static void afs_mntpt_expiry_timed_out(struct work_struct *work) 292 { 293 _enter(""); 294 295 if (!list_empty(&afs_vfsmounts)) { 296 mark_mounts_for_expiry(&afs_vfsmounts); 297 schedule_delayed_work(&afs_mntpt_expiry_timer, 298 afs_mntpt_expiry_timeout * HZ); 299 } 300 301 _leave(""); 302 } 303 304 /* 305 * kill the AFS mountpoint timer if it's still running 306 */ 307 void afs_mntpt_kill_timer(void) 308 { 309 _enter(""); 310 311 ASSERT(list_empty(&afs_vfsmounts)); 312 cancel_delayed_work(&afs_mntpt_expiry_timer); 313 flush_scheduled_work(); 314 } 315