1 /* dir.c: AFS dynamic root handling 2 * 3 * Copyright (C) 2018 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 Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11 12 #include <linux/fs.h> 13 #include <linux/namei.h> 14 #include <linux/dns_resolver.h> 15 #include "internal.h" 16 17 const struct file_operations afs_dynroot_file_operations = { 18 .open = dcache_dir_open, 19 .release = dcache_dir_close, 20 .iterate_shared = dcache_readdir, 21 .llseek = dcache_dir_lseek, 22 }; 23 24 /* 25 * Probe to see if a cell may exist. This prevents positive dentries from 26 * being created unnecessarily. 27 */ 28 static int afs_probe_cell_name(struct dentry *dentry) 29 { 30 struct afs_cell *cell; 31 const char *name = dentry->d_name.name; 32 size_t len = dentry->d_name.len; 33 int ret; 34 35 /* Names prefixed with a dot are R/W mounts. */ 36 if (name[0] == '.') { 37 if (len == 1) 38 return -EINVAL; 39 name++; 40 len--; 41 } 42 43 cell = afs_lookup_cell_rcu(afs_d2net(dentry), name, len); 44 if (!IS_ERR(cell)) { 45 afs_put_cell(afs_d2net(dentry), cell); 46 return 0; 47 } 48 49 ret = dns_query("afsdb", name, len, "ipv4", NULL, NULL); 50 if (ret == -ENODATA) 51 ret = -EDESTADDRREQ; 52 return ret; 53 } 54 55 /* 56 * Try to auto mount the mountpoint with pseudo directory, if the autocell 57 * operation is setted. 58 */ 59 struct inode *afs_try_auto_mntpt(struct dentry *dentry, struct inode *dir) 60 { 61 struct afs_vnode *vnode = AFS_FS_I(dir); 62 struct inode *inode; 63 int ret = -ENOENT; 64 65 _enter("%p{%pd}, {%x:%u}", 66 dentry, dentry, vnode->fid.vid, vnode->fid.vnode); 67 68 if (!test_bit(AFS_VNODE_AUTOCELL, &vnode->flags)) 69 goto out; 70 71 ret = afs_probe_cell_name(dentry); 72 if (ret < 0) 73 goto out; 74 75 inode = afs_iget_pseudo_dir(dir->i_sb, false); 76 if (IS_ERR(inode)) { 77 ret = PTR_ERR(inode); 78 goto out; 79 } 80 81 _leave("= %p", inode); 82 return inode; 83 84 out: 85 _leave("= %d", ret); 86 return ERR_PTR(ret); 87 } 88 89 /* 90 * Look up @cell in a dynroot directory. This is a substitution for the 91 * local cell name for the net namespace. 92 */ 93 static struct dentry *afs_lookup_atcell(struct dentry *dentry) 94 { 95 struct afs_cell *cell; 96 struct afs_net *net = afs_d2net(dentry); 97 struct dentry *ret; 98 unsigned int seq = 0; 99 char *name; 100 int len; 101 102 if (!net->ws_cell) 103 return ERR_PTR(-ENOENT); 104 105 ret = ERR_PTR(-ENOMEM); 106 name = kmalloc(AFS_MAXCELLNAME + 1, GFP_KERNEL); 107 if (!name) 108 goto out_p; 109 110 rcu_read_lock(); 111 do { 112 read_seqbegin_or_lock(&net->cells_lock, &seq); 113 cell = rcu_dereference_raw(net->ws_cell); 114 if (cell) { 115 len = cell->name_len; 116 memcpy(name, cell->name, len + 1); 117 } 118 } while (need_seqretry(&net->cells_lock, seq)); 119 done_seqretry(&net->cells_lock, seq); 120 rcu_read_unlock(); 121 122 ret = ERR_PTR(-ENOENT); 123 if (!cell) 124 goto out_n; 125 126 ret = lookup_one_len(name, dentry->d_parent, len); 127 128 /* We don't want to d_add() the @cell dentry here as we don't want to 129 * the cached dentry to hide changes to the local cell name. 130 */ 131 132 out_n: 133 kfree(name); 134 out_p: 135 return ret; 136 } 137 138 /* 139 * Look up an entry in a dynroot directory. 140 */ 141 static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentry, 142 unsigned int flags) 143 { 144 struct afs_vnode *vnode; 145 struct inode *inode; 146 int ret; 147 148 vnode = AFS_FS_I(dir); 149 150 _enter("%pd", dentry); 151 152 ASSERTCMP(d_inode(dentry), ==, NULL); 153 154 if (dentry->d_name.len >= AFSNAMEMAX) { 155 _leave(" = -ENAMETOOLONG"); 156 return ERR_PTR(-ENAMETOOLONG); 157 } 158 159 if (dentry->d_name.len == 5 && 160 memcmp(dentry->d_name.name, "@cell", 5) == 0) 161 return afs_lookup_atcell(dentry); 162 163 inode = afs_try_auto_mntpt(dentry, dir); 164 if (IS_ERR(inode)) { 165 ret = PTR_ERR(inode); 166 if (ret == -ENOENT) { 167 d_add(dentry, NULL); 168 _leave(" = NULL [negative]"); 169 return NULL; 170 } 171 _leave(" = %d [do]", ret); 172 return ERR_PTR(ret); 173 } 174 175 d_add(dentry, inode); 176 _leave(" = 0 { ino=%lu v=%u }", 177 d_inode(dentry)->i_ino, d_inode(dentry)->i_generation); 178 return NULL; 179 } 180 181 const struct inode_operations afs_dynroot_inode_operations = { 182 .lookup = afs_dynroot_lookup, 183 }; 184 185 /* 186 * Dirs in the dynamic root don't need revalidation. 187 */ 188 static int afs_dynroot_d_revalidate(struct dentry *dentry, unsigned int flags) 189 { 190 return 1; 191 } 192 193 /* 194 * Allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 195 * sleep) 196 * - called from dput() when d_count is going to 0. 197 * - return 1 to request dentry be unhashed, 0 otherwise 198 */ 199 static int afs_dynroot_d_delete(const struct dentry *dentry) 200 { 201 return d_really_is_positive(dentry); 202 } 203 204 const struct dentry_operations afs_dynroot_dentry_operations = { 205 .d_revalidate = afs_dynroot_d_revalidate, 206 .d_delete = afs_dynroot_d_delete, 207 .d_release = afs_d_release, 208 .d_automount = afs_d_automount, 209 }; 210