1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * (C) 2001 Clemson University and The University of Chicago 4 * 5 * See COPYING in top-level directory. 6 */ 7 8 /* 9 * Linux VFS namei operations. 10 */ 11 12 #include "protocol.h" 13 #include "orangefs-kernel.h" 14 15 /* 16 * Get a newly allocated inode to go with a negative dentry. 17 */ 18 static int orangefs_create(struct user_namespace *mnt_userns, 19 struct inode *dir, 20 struct dentry *dentry, 21 umode_t mode, 22 bool exclusive) 23 { 24 struct orangefs_inode_s *parent = ORANGEFS_I(dir); 25 struct orangefs_kernel_op_s *new_op; 26 struct orangefs_object_kref ref; 27 struct inode *inode; 28 struct iattr iattr; 29 int ret; 30 31 gossip_debug(GOSSIP_NAME_DEBUG, "%s: %pd\n", 32 __func__, 33 dentry); 34 35 new_op = op_alloc(ORANGEFS_VFS_OP_CREATE); 36 if (!new_op) 37 return -ENOMEM; 38 39 new_op->upcall.req.create.parent_refn = parent->refn; 40 41 fill_default_sys_attrs(new_op->upcall.req.create.attributes, 42 ORANGEFS_TYPE_METAFILE, mode); 43 44 strncpy(new_op->upcall.req.create.d_name, 45 dentry->d_name.name, ORANGEFS_NAME_MAX - 1); 46 47 ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 48 49 gossip_debug(GOSSIP_NAME_DEBUG, 50 "%s: %pd: handle:%pU: fsid:%d: new_op:%p: ret:%d:\n", 51 __func__, 52 dentry, 53 &new_op->downcall.resp.create.refn.khandle, 54 new_op->downcall.resp.create.refn.fs_id, 55 new_op, 56 ret); 57 58 if (ret < 0) 59 goto out; 60 61 ref = new_op->downcall.resp.create.refn; 62 63 inode = orangefs_new_inode(dir->i_sb, dir, S_IFREG | mode, 0, &ref); 64 if (IS_ERR(inode)) { 65 gossip_err("%s: Failed to allocate inode for file :%pd:\n", 66 __func__, 67 dentry); 68 ret = PTR_ERR(inode); 69 goto out; 70 } 71 72 gossip_debug(GOSSIP_NAME_DEBUG, 73 "%s: Assigned inode :%pU: for file :%pd:\n", 74 __func__, 75 get_khandle_from_ino(inode), 76 dentry); 77 78 d_instantiate_new(dentry, inode); 79 orangefs_set_timeout(dentry); 80 81 gossip_debug(GOSSIP_NAME_DEBUG, 82 "%s: dentry instantiated for %pd\n", 83 __func__, 84 dentry); 85 86 memset(&iattr, 0, sizeof iattr); 87 iattr.ia_valid |= ATTR_MTIME | ATTR_CTIME; 88 iattr.ia_mtime = iattr.ia_ctime = current_time(dir); 89 __orangefs_setattr(dir, &iattr); 90 ret = 0; 91 out: 92 op_release(new_op); 93 gossip_debug(GOSSIP_NAME_DEBUG, 94 "%s: %pd: returning %d\n", 95 __func__, 96 dentry, 97 ret); 98 return ret; 99 } 100 101 /* 102 * Attempt to resolve an object name (dentry->d_name), parent handle, and 103 * fsid into a handle for the object. 104 */ 105 static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry, 106 unsigned int flags) 107 { 108 struct orangefs_inode_s *parent = ORANGEFS_I(dir); 109 struct orangefs_kernel_op_s *new_op; 110 struct inode *inode; 111 int ret = -EINVAL; 112 113 /* 114 * in theory we could skip a lookup here (if the intent is to 115 * create) in order to avoid a potentially failed lookup, but 116 * leaving it in can skip a valid lookup and try to create a file 117 * that already exists (e.g. the vfs already handles checking for 118 * -EEXIST on O_EXCL opens, which is broken if we skip this lookup 119 * in the create path) 120 */ 121 gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %pd\n", 122 __func__, dentry); 123 124 if (dentry->d_name.len > (ORANGEFS_NAME_MAX - 1)) 125 return ERR_PTR(-ENAMETOOLONG); 126 127 new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP); 128 if (!new_op) 129 return ERR_PTR(-ENOMEM); 130 131 new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW; 132 133 gossip_debug(GOSSIP_NAME_DEBUG, "%s:%s:%d using parent %pU\n", 134 __FILE__, 135 __func__, 136 __LINE__, 137 &parent->refn.khandle); 138 new_op->upcall.req.lookup.parent_refn = parent->refn; 139 140 strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name, 141 ORANGEFS_NAME_MAX - 1); 142 143 gossip_debug(GOSSIP_NAME_DEBUG, 144 "%s: doing lookup on %s under %pU,%d\n", 145 __func__, 146 new_op->upcall.req.lookup.d_name, 147 &new_op->upcall.req.lookup.parent_refn.khandle, 148 new_op->upcall.req.lookup.parent_refn.fs_id); 149 150 ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 151 152 gossip_debug(GOSSIP_NAME_DEBUG, 153 "Lookup Got %pU, fsid %d (ret=%d)\n", 154 &new_op->downcall.resp.lookup.refn.khandle, 155 new_op->downcall.resp.lookup.refn.fs_id, 156 ret); 157 158 if (ret == 0) { 159 orangefs_set_timeout(dentry); 160 inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn); 161 } else if (ret == -ENOENT) { 162 inode = NULL; 163 } else { 164 /* must be a non-recoverable error */ 165 inode = ERR_PTR(ret); 166 } 167 168 op_release(new_op); 169 return d_splice_alias(inode, dentry); 170 } 171 172 /* return 0 on success; non-zero otherwise */ 173 static int orangefs_unlink(struct inode *dir, struct dentry *dentry) 174 { 175 struct inode *inode = dentry->d_inode; 176 struct orangefs_inode_s *parent = ORANGEFS_I(dir); 177 struct orangefs_kernel_op_s *new_op; 178 struct iattr iattr; 179 int ret; 180 181 gossip_debug(GOSSIP_NAME_DEBUG, 182 "%s: called on %pd\n" 183 " (inode %pU): Parent is %pU | fs_id %d\n", 184 __func__, 185 dentry, 186 get_khandle_from_ino(inode), 187 &parent->refn.khandle, 188 parent->refn.fs_id); 189 190 new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE); 191 if (!new_op) 192 return -ENOMEM; 193 194 new_op->upcall.req.remove.parent_refn = parent->refn; 195 strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name, 196 ORANGEFS_NAME_MAX - 1); 197 198 ret = service_operation(new_op, "orangefs_unlink", 199 get_interruptible_flag(inode)); 200 201 gossip_debug(GOSSIP_NAME_DEBUG, 202 "%s: service_operation returned:%d:\n", 203 __func__, 204 ret); 205 206 op_release(new_op); 207 208 if (!ret) { 209 drop_nlink(inode); 210 211 memset(&iattr, 0, sizeof iattr); 212 iattr.ia_valid |= ATTR_MTIME | ATTR_CTIME; 213 iattr.ia_mtime = iattr.ia_ctime = current_time(dir); 214 __orangefs_setattr(dir, &iattr); 215 } 216 return ret; 217 } 218 219 static int orangefs_symlink(struct user_namespace *mnt_userns, 220 struct inode *dir, 221 struct dentry *dentry, 222 const char *symname) 223 { 224 struct orangefs_inode_s *parent = ORANGEFS_I(dir); 225 struct orangefs_kernel_op_s *new_op; 226 struct orangefs_object_kref ref; 227 struct inode *inode; 228 struct iattr iattr; 229 int mode = 0755; 230 int ret; 231 232 gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__); 233 234 if (!symname) 235 return -EINVAL; 236 237 if (strlen(symname)+1 > ORANGEFS_NAME_MAX) 238 return -ENAMETOOLONG; 239 240 new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK); 241 if (!new_op) 242 return -ENOMEM; 243 244 new_op->upcall.req.sym.parent_refn = parent->refn; 245 246 fill_default_sys_attrs(new_op->upcall.req.sym.attributes, 247 ORANGEFS_TYPE_SYMLINK, 248 mode); 249 250 strncpy(new_op->upcall.req.sym.entry_name, 251 dentry->d_name.name, 252 ORANGEFS_NAME_MAX - 1); 253 strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_MAX - 1); 254 255 ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 256 257 gossip_debug(GOSSIP_NAME_DEBUG, 258 "Symlink Got ORANGEFS handle %pU on fsid %d (ret=%d)\n", 259 &new_op->downcall.resp.sym.refn.khandle, 260 new_op->downcall.resp.sym.refn.fs_id, ret); 261 262 if (ret < 0) { 263 gossip_debug(GOSSIP_NAME_DEBUG, 264 "%s: failed with error code %d\n", 265 __func__, ret); 266 goto out; 267 } 268 269 ref = new_op->downcall.resp.sym.refn; 270 271 inode = orangefs_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0, &ref); 272 if (IS_ERR(inode)) { 273 gossip_err 274 ("*** Failed to allocate orangefs symlink inode\n"); 275 ret = PTR_ERR(inode); 276 goto out; 277 } 278 /* 279 * This is necessary because orangefs_inode_getattr will not 280 * re-read symlink size as it is impossible for it to change. 281 * Invalidating the cache does not help. orangefs_new_inode 282 * does not set the correct size (it does not know symname). 283 */ 284 inode->i_size = strlen(symname); 285 286 gossip_debug(GOSSIP_NAME_DEBUG, 287 "Assigned symlink inode new number of %pU\n", 288 get_khandle_from_ino(inode)); 289 290 d_instantiate_new(dentry, inode); 291 orangefs_set_timeout(dentry); 292 293 gossip_debug(GOSSIP_NAME_DEBUG, 294 "Inode (Symlink) %pU -> %pd\n", 295 get_khandle_from_ino(inode), 296 dentry); 297 298 memset(&iattr, 0, sizeof iattr); 299 iattr.ia_valid |= ATTR_MTIME | ATTR_CTIME; 300 iattr.ia_mtime = iattr.ia_ctime = current_time(dir); 301 __orangefs_setattr(dir, &iattr); 302 ret = 0; 303 out: 304 op_release(new_op); 305 return ret; 306 } 307 308 static int orangefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir, 309 struct dentry *dentry, umode_t mode) 310 { 311 struct orangefs_inode_s *parent = ORANGEFS_I(dir); 312 struct orangefs_kernel_op_s *new_op; 313 struct orangefs_object_kref ref; 314 struct inode *inode; 315 struct iattr iattr; 316 int ret; 317 318 new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR); 319 if (!new_op) 320 return -ENOMEM; 321 322 new_op->upcall.req.mkdir.parent_refn = parent->refn; 323 324 fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes, 325 ORANGEFS_TYPE_DIRECTORY, mode); 326 327 strncpy(new_op->upcall.req.mkdir.d_name, 328 dentry->d_name.name, ORANGEFS_NAME_MAX - 1); 329 330 ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 331 332 gossip_debug(GOSSIP_NAME_DEBUG, 333 "Mkdir Got ORANGEFS handle %pU on fsid %d\n", 334 &new_op->downcall.resp.mkdir.refn.khandle, 335 new_op->downcall.resp.mkdir.refn.fs_id); 336 337 if (ret < 0) { 338 gossip_debug(GOSSIP_NAME_DEBUG, 339 "%s: failed with error code %d\n", 340 __func__, ret); 341 goto out; 342 } 343 344 ref = new_op->downcall.resp.mkdir.refn; 345 346 inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0, &ref); 347 if (IS_ERR(inode)) { 348 gossip_err("*** Failed to allocate orangefs dir inode\n"); 349 ret = PTR_ERR(inode); 350 goto out; 351 } 352 353 gossip_debug(GOSSIP_NAME_DEBUG, 354 "Assigned dir inode new number of %pU\n", 355 get_khandle_from_ino(inode)); 356 357 d_instantiate_new(dentry, inode); 358 orangefs_set_timeout(dentry); 359 360 gossip_debug(GOSSIP_NAME_DEBUG, 361 "Inode (Directory) %pU -> %pd\n", 362 get_khandle_from_ino(inode), 363 dentry); 364 365 /* 366 * NOTE: we have no good way to keep nlink consistent for directories 367 * across clients; keep constant at 1. 368 */ 369 memset(&iattr, 0, sizeof iattr); 370 iattr.ia_valid |= ATTR_MTIME | ATTR_CTIME; 371 iattr.ia_mtime = iattr.ia_ctime = current_time(dir); 372 __orangefs_setattr(dir, &iattr); 373 out: 374 op_release(new_op); 375 return ret; 376 } 377 378 static int orangefs_rename(struct user_namespace *mnt_userns, 379 struct inode *old_dir, 380 struct dentry *old_dentry, 381 struct inode *new_dir, 382 struct dentry *new_dentry, 383 unsigned int flags) 384 { 385 struct orangefs_kernel_op_s *new_op; 386 struct iattr iattr; 387 int ret; 388 389 if (flags) 390 return -EINVAL; 391 392 gossip_debug(GOSSIP_NAME_DEBUG, 393 "orangefs_rename: called (%pd2 => %pd2) ct=%d\n", 394 old_dentry, new_dentry, d_count(new_dentry)); 395 396 memset(&iattr, 0, sizeof iattr); 397 iattr.ia_valid |= ATTR_MTIME | ATTR_CTIME; 398 iattr.ia_mtime = iattr.ia_ctime = current_time(new_dir); 399 __orangefs_setattr(new_dir, &iattr); 400 401 new_op = op_alloc(ORANGEFS_VFS_OP_RENAME); 402 if (!new_op) 403 return -EINVAL; 404 405 new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn; 406 new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn; 407 408 strncpy(new_op->upcall.req.rename.d_old_name, 409 old_dentry->d_name.name, 410 ORANGEFS_NAME_MAX - 1); 411 strncpy(new_op->upcall.req.rename.d_new_name, 412 new_dentry->d_name.name, 413 ORANGEFS_NAME_MAX - 1); 414 415 ret = service_operation(new_op, 416 "orangefs_rename", 417 get_interruptible_flag(old_dentry->d_inode)); 418 419 gossip_debug(GOSSIP_NAME_DEBUG, 420 "orangefs_rename: got downcall status %d\n", 421 ret); 422 423 if (new_dentry->d_inode) 424 new_dentry->d_inode->i_ctime = current_time(new_dentry->d_inode); 425 426 op_release(new_op); 427 return ret; 428 } 429 430 /* ORANGEFS implementation of VFS inode operations for directories */ 431 const struct inode_operations orangefs_dir_inode_operations = { 432 .lookup = orangefs_lookup, 433 .get_acl = orangefs_get_acl, 434 .set_acl = orangefs_set_acl, 435 .create = orangefs_create, 436 .unlink = orangefs_unlink, 437 .symlink = orangefs_symlink, 438 .mkdir = orangefs_mkdir, 439 .rmdir = orangefs_unlink, 440 .rename = orangefs_rename, 441 .setattr = orangefs_setattr, 442 .getattr = orangefs_getattr, 443 .listxattr = orangefs_listxattr, 444 .permission = orangefs_permission, 445 .update_time = orangefs_update_time, 446 }; 447