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_expiry_timed_out(struct work_struct *work); 28 29 const struct file_operations afs_mntpt_file_operations = { 30 .open = afs_mntpt_open, 31 .llseek = noop_llseek, 32 }; 33 34 const struct inode_operations afs_mntpt_inode_operations = { 35 .lookup = afs_mntpt_lookup, 36 .readlink = page_readlink, 37 .getattr = afs_getattr, 38 }; 39 40 const struct inode_operations afs_autocell_inode_operations = { 41 .getattr = afs_getattr, 42 }; 43 44 static LIST_HEAD(afs_vfsmounts); 45 static DECLARE_DELAYED_WORK(afs_mntpt_expiry_timer, afs_mntpt_expiry_timed_out); 46 47 static unsigned long afs_mntpt_expiry_timeout = 10 * 60; 48 49 /* 50 * check a symbolic link to see whether it actually encodes a mountpoint 51 * - sets the AFS_VNODE_MOUNTPOINT flag on the vnode appropriately 52 */ 53 int afs_mntpt_check_symlink(struct afs_vnode *vnode, struct key *key) 54 { 55 struct page *page; 56 size_t size; 57 char *buf; 58 int ret; 59 60 _enter("{%x:%u,%u}", 61 vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); 62 63 /* read the contents of the symlink into the pagecache */ 64 page = read_cache_page(AFS_VNODE_TO_I(vnode)->i_mapping, 0, 65 afs_page_filler, key); 66 if (IS_ERR(page)) { 67 ret = PTR_ERR(page); 68 goto out; 69 } 70 71 ret = -EIO; 72 if (PageError(page)) 73 goto out_free; 74 75 buf = kmap(page); 76 77 /* examine the symlink's contents */ 78 size = vnode->status.size; 79 _debug("symlink to %*.*s", (int) size, (int) size, buf); 80 81 if (size > 2 && 82 (buf[0] == '%' || buf[0] == '#') && 83 buf[size - 1] == '.' 84 ) { 85 _debug("symlink is a mountpoint"); 86 spin_lock(&vnode->lock); 87 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); 88 vnode->vfs_inode.i_flags |= S_AUTOMOUNT; 89 spin_unlock(&vnode->lock); 90 } 91 92 ret = 0; 93 94 kunmap(page); 95 out_free: 96 page_cache_release(page); 97 out: 98 _leave(" = %d", ret); 99 return ret; 100 } 101 102 /* 103 * no valid lookup procedure on this sort of dir 104 */ 105 static struct dentry *afs_mntpt_lookup(struct inode *dir, 106 struct dentry *dentry, 107 struct nameidata *nd) 108 { 109 _enter("%p,%p{%p{%s},%s}", 110 dir, 111 dentry, 112 dentry->d_parent, 113 dentry->d_parent ? 114 dentry->d_parent->d_name.name : (const unsigned char *) "", 115 dentry->d_name.name); 116 117 return ERR_PTR(-EREMOTE); 118 } 119 120 /* 121 * no valid open procedure on this sort of dir 122 */ 123 static int afs_mntpt_open(struct inode *inode, struct file *file) 124 { 125 _enter("%p,%p{%p{%s},%s}", 126 inode, file, 127 file->f_path.dentry->d_parent, 128 file->f_path.dentry->d_parent ? 129 file->f_path.dentry->d_parent->d_name.name : 130 (const unsigned char *) "", 131 file->f_path.dentry->d_name.name); 132 133 return -EREMOTE; 134 } 135 136 /* 137 * create a vfsmount to be automounted 138 */ 139 static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt) 140 { 141 struct afs_super_info *super; 142 struct vfsmount *mnt; 143 struct afs_vnode *vnode; 144 struct page *page; 145 char *devname, *options; 146 bool rwpath = false; 147 int ret; 148 149 _enter("{%s}", mntpt->d_name.name); 150 151 BUG_ON(!mntpt->d_inode); 152 153 ret = -ENOMEM; 154 devname = (char *) get_zeroed_page(GFP_KERNEL); 155 if (!devname) 156 goto error_no_devname; 157 158 options = (char *) get_zeroed_page(GFP_KERNEL); 159 if (!options) 160 goto error_no_options; 161 162 vnode = AFS_FS_I(mntpt->d_inode); 163 if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) { 164 /* if the directory is a pseudo directory, use the d_name */ 165 static const char afs_root_cell[] = ":root.cell."; 166 unsigned size = mntpt->d_name.len; 167 168 ret = -ENOENT; 169 if (size < 2 || size > AFS_MAXCELLNAME) 170 goto error_no_page; 171 172 if (mntpt->d_name.name[0] == '.') { 173 devname[0] = '#'; 174 memcpy(devname + 1, mntpt->d_name.name, size - 1); 175 memcpy(devname + size, afs_root_cell, 176 sizeof(afs_root_cell)); 177 rwpath = true; 178 } else { 179 devname[0] = '%'; 180 memcpy(devname + 1, mntpt->d_name.name, size); 181 memcpy(devname + size + 1, afs_root_cell, 182 sizeof(afs_root_cell)); 183 } 184 } else { 185 /* read the contents of the AFS special symlink */ 186 loff_t size = i_size_read(mntpt->d_inode); 187 char *buf; 188 189 ret = -EINVAL; 190 if (size > PAGE_SIZE - 1) 191 goto error_no_page; 192 193 page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL); 194 if (IS_ERR(page)) { 195 ret = PTR_ERR(page); 196 goto error_no_page; 197 } 198 199 ret = -EIO; 200 if (PageError(page)) 201 goto error; 202 203 buf = kmap_atomic(page, KM_USER0); 204 memcpy(devname, buf, size); 205 kunmap_atomic(buf, KM_USER0); 206 page_cache_release(page); 207 page = NULL; 208 } 209 210 /* work out what options we want */ 211 super = AFS_FS_S(mntpt->d_sb); 212 memcpy(options, "cell=", 5); 213 strcpy(options + 5, super->volume->cell->name); 214 if (super->volume->type == AFSVL_RWVOL || rwpath) 215 strcat(options, ",rwpath"); 216 217 /* try and do the mount */ 218 _debug("--- attempting mount %s -o %s ---", devname, options); 219 mnt = vfs_kern_mount(&afs_fs_type, 0, devname, options); 220 _debug("--- mount result %p ---", mnt); 221 222 free_page((unsigned long) devname); 223 free_page((unsigned long) options); 224 _leave(" = %p", mnt); 225 return mnt; 226 227 error: 228 page_cache_release(page); 229 error_no_page: 230 free_page((unsigned long) options); 231 error_no_options: 232 free_page((unsigned long) devname); 233 error_no_devname: 234 _leave(" = %d", ret); 235 return ERR_PTR(ret); 236 } 237 238 /* 239 * handle an automount point 240 */ 241 struct vfsmount *afs_d_automount(struct path *path) 242 { 243 struct vfsmount *newmnt; 244 245 _enter("{%s}", path->dentry->d_name.name); 246 247 newmnt = afs_mntpt_do_automount(path->dentry); 248 if (IS_ERR(newmnt)) 249 return newmnt; 250 251 mntget(newmnt); /* prevent immediate expiration */ 252 mnt_set_expiry(newmnt, &afs_vfsmounts); 253 queue_delayed_work(afs_wq, &afs_mntpt_expiry_timer, 254 afs_mntpt_expiry_timeout * HZ); 255 _leave(" = %p", newmnt); 256 return newmnt; 257 } 258 259 /* 260 * handle mountpoint expiry timer going off 261 */ 262 static void afs_mntpt_expiry_timed_out(struct work_struct *work) 263 { 264 _enter(""); 265 266 if (!list_empty(&afs_vfsmounts)) { 267 mark_mounts_for_expiry(&afs_vfsmounts); 268 queue_delayed_work(afs_wq, &afs_mntpt_expiry_timer, 269 afs_mntpt_expiry_timeout * HZ); 270 } 271 272 _leave(""); 273 } 274 275 /* 276 * kill the AFS mountpoint timer if it's still running 277 */ 278 void afs_mntpt_kill_timer(void) 279 { 280 _enter(""); 281 282 ASSERT(list_empty(&afs_vfsmounts)); 283 cancel_delayed_work_sync(&afs_mntpt_expiry_timer); 284 } 285