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