1 // SPDX-License-Identifier: GPL-2.0 2 3 #include "bcachefs.h" 4 #include "acl.h" 5 #include "btree_update.h" 6 #include "dirent.h" 7 #include "fs-common.h" 8 #include "inode.h" 9 #include "subvolume.h" 10 #include "xattr.h" 11 12 #include <linux/posix_acl.h> 13 14 static inline int is_subdir_for_nlink(struct bch_inode_unpacked *inode) 15 { 16 return S_ISDIR(inode->bi_mode) && !inode->bi_subvol; 17 } 18 19 int bch2_create_trans(struct btree_trans *trans, 20 subvol_inum dir, 21 struct bch_inode_unpacked *dir_u, 22 struct bch_inode_unpacked *new_inode, 23 const struct qstr *name, 24 uid_t uid, gid_t gid, umode_t mode, dev_t rdev, 25 struct posix_acl *default_acl, 26 struct posix_acl *acl, 27 subvol_inum snapshot_src, 28 unsigned flags) 29 { 30 struct bch_fs *c = trans->c; 31 struct btree_iter dir_iter = { NULL }; 32 struct btree_iter inode_iter = { NULL }; 33 subvol_inum new_inum = dir; 34 u64 now = bch2_current_time(c); 35 u64 cpu = raw_smp_processor_id(); 36 u64 dir_target; 37 u32 snapshot; 38 unsigned dir_type = mode_to_type(mode); 39 int ret; 40 41 ret = bch2_subvolume_get_snapshot(trans, dir.subvol, &snapshot); 42 if (ret) 43 goto err; 44 45 ret = bch2_inode_peek(trans, &dir_iter, dir_u, dir, BTREE_ITER_INTENT); 46 if (ret) 47 goto err; 48 49 if (!(flags & BCH_CREATE_SNAPSHOT)) { 50 /* Normal create path - allocate a new inode: */ 51 bch2_inode_init_late(new_inode, now, uid, gid, mode, rdev, dir_u); 52 53 if (flags & BCH_CREATE_TMPFILE) 54 new_inode->bi_flags |= BCH_INODE_unlinked; 55 56 ret = bch2_inode_create(trans, &inode_iter, new_inode, snapshot, cpu); 57 if (ret) 58 goto err; 59 60 snapshot_src = (subvol_inum) { 0 }; 61 } else { 62 /* 63 * Creating a snapshot - we're not allocating a new inode, but 64 * we do have to lookup the root inode of the subvolume we're 65 * snapshotting and update it (in the new snapshot): 66 */ 67 68 if (!snapshot_src.inum) { 69 /* Inode wasn't specified, just snapshot: */ 70 struct bch_subvolume s; 71 72 ret = bch2_subvolume_get(trans, snapshot_src.subvol, true, 73 BTREE_ITER_CACHED, &s); 74 if (ret) 75 goto err; 76 77 snapshot_src.inum = le64_to_cpu(s.inode); 78 } 79 80 ret = bch2_inode_peek(trans, &inode_iter, new_inode, snapshot_src, 81 BTREE_ITER_INTENT); 82 if (ret) 83 goto err; 84 85 if (new_inode->bi_subvol != snapshot_src.subvol) { 86 /* Not a subvolume root: */ 87 ret = -EINVAL; 88 goto err; 89 } 90 91 /* 92 * If we're not root, we have to own the subvolume being 93 * snapshotted: 94 */ 95 if (uid && new_inode->bi_uid != uid) { 96 ret = -EPERM; 97 goto err; 98 } 99 100 flags |= BCH_CREATE_SUBVOL; 101 } 102 103 new_inum.inum = new_inode->bi_inum; 104 dir_target = new_inode->bi_inum; 105 106 if (flags & BCH_CREATE_SUBVOL) { 107 u32 new_subvol, dir_snapshot; 108 109 ret = bch2_subvolume_create(trans, new_inode->bi_inum, 110 snapshot_src.subvol, 111 &new_subvol, &snapshot, 112 (flags & BCH_CREATE_SNAPSHOT_RO) != 0); 113 if (ret) 114 goto err; 115 116 new_inode->bi_parent_subvol = dir.subvol; 117 new_inode->bi_subvol = new_subvol; 118 new_inum.subvol = new_subvol; 119 dir_target = new_subvol; 120 dir_type = DT_SUBVOL; 121 122 ret = bch2_subvolume_get_snapshot(trans, dir.subvol, &dir_snapshot); 123 if (ret) 124 goto err; 125 126 bch2_btree_iter_set_snapshot(&dir_iter, dir_snapshot); 127 ret = bch2_btree_iter_traverse(&dir_iter); 128 if (ret) 129 goto err; 130 } 131 132 if (!(flags & BCH_CREATE_SNAPSHOT)) { 133 if (default_acl) { 134 ret = bch2_set_acl_trans(trans, new_inum, new_inode, 135 default_acl, ACL_TYPE_DEFAULT); 136 if (ret) 137 goto err; 138 } 139 140 if (acl) { 141 ret = bch2_set_acl_trans(trans, new_inum, new_inode, 142 acl, ACL_TYPE_ACCESS); 143 if (ret) 144 goto err; 145 } 146 } 147 148 if (!(flags & BCH_CREATE_TMPFILE)) { 149 struct bch_hash_info dir_hash = bch2_hash_info_init(c, dir_u); 150 u64 dir_offset; 151 152 if (is_subdir_for_nlink(new_inode)) 153 dir_u->bi_nlink++; 154 dir_u->bi_mtime = dir_u->bi_ctime = now; 155 156 ret = bch2_inode_write(trans, &dir_iter, dir_u); 157 if (ret) 158 goto err; 159 160 ret = bch2_dirent_create(trans, dir, &dir_hash, 161 dir_type, 162 name, 163 dir_target, 164 &dir_offset, 165 BCH_HASH_SET_MUST_CREATE); 166 if (ret) 167 goto err; 168 169 if (c->sb.version >= bcachefs_metadata_version_inode_backpointers) { 170 new_inode->bi_dir = dir_u->bi_inum; 171 new_inode->bi_dir_offset = dir_offset; 172 } 173 } 174 175 inode_iter.flags &= ~BTREE_ITER_ALL_SNAPSHOTS; 176 bch2_btree_iter_set_snapshot(&inode_iter, snapshot); 177 178 ret = bch2_btree_iter_traverse(&inode_iter) ?: 179 bch2_inode_write(trans, &inode_iter, new_inode); 180 err: 181 bch2_trans_iter_exit(trans, &inode_iter); 182 bch2_trans_iter_exit(trans, &dir_iter); 183 return ret; 184 } 185 186 int bch2_link_trans(struct btree_trans *trans, 187 subvol_inum dir, struct bch_inode_unpacked *dir_u, 188 subvol_inum inum, struct bch_inode_unpacked *inode_u, 189 const struct qstr *name) 190 { 191 struct bch_fs *c = trans->c; 192 struct btree_iter dir_iter = { NULL }; 193 struct btree_iter inode_iter = { NULL }; 194 struct bch_hash_info dir_hash; 195 u64 now = bch2_current_time(c); 196 u64 dir_offset = 0; 197 int ret; 198 199 if (dir.subvol != inum.subvol) 200 return -EXDEV; 201 202 ret = bch2_inode_peek(trans, &inode_iter, inode_u, inum, BTREE_ITER_INTENT); 203 if (ret) 204 goto err; 205 206 inode_u->bi_ctime = now; 207 ret = bch2_inode_nlink_inc(inode_u); 208 if (ret) 209 return ret; 210 211 ret = bch2_inode_peek(trans, &dir_iter, dir_u, dir, BTREE_ITER_INTENT); 212 if (ret) 213 goto err; 214 215 if (bch2_reinherit_attrs(inode_u, dir_u)) { 216 ret = -EXDEV; 217 goto err; 218 } 219 220 dir_u->bi_mtime = dir_u->bi_ctime = now; 221 222 dir_hash = bch2_hash_info_init(c, dir_u); 223 224 ret = bch2_dirent_create(trans, dir, &dir_hash, 225 mode_to_type(inode_u->bi_mode), 226 name, inum.inum, &dir_offset, 227 BCH_HASH_SET_MUST_CREATE); 228 if (ret) 229 goto err; 230 231 if (c->sb.version >= bcachefs_metadata_version_inode_backpointers) { 232 inode_u->bi_dir = dir.inum; 233 inode_u->bi_dir_offset = dir_offset; 234 } 235 236 ret = bch2_inode_write(trans, &dir_iter, dir_u) ?: 237 bch2_inode_write(trans, &inode_iter, inode_u); 238 err: 239 bch2_trans_iter_exit(trans, &dir_iter); 240 bch2_trans_iter_exit(trans, &inode_iter); 241 return ret; 242 } 243 244 int bch2_unlink_trans(struct btree_trans *trans, 245 subvol_inum dir, 246 struct bch_inode_unpacked *dir_u, 247 struct bch_inode_unpacked *inode_u, 248 const struct qstr *name, 249 bool deleting_snapshot) 250 { 251 struct bch_fs *c = trans->c; 252 struct btree_iter dir_iter = { NULL }; 253 struct btree_iter dirent_iter = { NULL }; 254 struct btree_iter inode_iter = { NULL }; 255 struct bch_hash_info dir_hash; 256 subvol_inum inum; 257 u64 now = bch2_current_time(c); 258 struct bkey_s_c k; 259 int ret; 260 261 ret = bch2_inode_peek(trans, &dir_iter, dir_u, dir, BTREE_ITER_INTENT); 262 if (ret) 263 goto err; 264 265 dir_hash = bch2_hash_info_init(c, dir_u); 266 267 ret = __bch2_dirent_lookup_trans(trans, &dirent_iter, dir, &dir_hash, 268 name, &inum, BTREE_ITER_INTENT); 269 if (ret) 270 goto err; 271 272 ret = bch2_inode_peek(trans, &inode_iter, inode_u, inum, 273 BTREE_ITER_INTENT); 274 if (ret) 275 goto err; 276 277 if (!deleting_snapshot && S_ISDIR(inode_u->bi_mode)) { 278 ret = bch2_empty_dir_trans(trans, inum); 279 if (ret) 280 goto err; 281 } 282 283 if (deleting_snapshot && !inode_u->bi_subvol) { 284 ret = -BCH_ERR_ENOENT_not_subvol; 285 goto err; 286 } 287 288 if (deleting_snapshot || inode_u->bi_subvol) { 289 ret = bch2_subvolume_unlink(trans, inode_u->bi_subvol); 290 if (ret) 291 goto err; 292 293 k = bch2_btree_iter_peek_slot(&dirent_iter); 294 ret = bkey_err(k); 295 if (ret) 296 goto err; 297 298 /* 299 * If we're deleting a subvolume, we need to really delete the 300 * dirent, not just emit a whiteout in the current snapshot: 301 */ 302 bch2_btree_iter_set_snapshot(&dirent_iter, k.k->p.snapshot); 303 ret = bch2_btree_iter_traverse(&dirent_iter); 304 if (ret) 305 goto err; 306 } else { 307 bch2_inode_nlink_dec(trans, inode_u); 308 } 309 310 if (inode_u->bi_dir == dirent_iter.pos.inode && 311 inode_u->bi_dir_offset == dirent_iter.pos.offset) { 312 inode_u->bi_dir = 0; 313 inode_u->bi_dir_offset = 0; 314 } 315 316 dir_u->bi_mtime = dir_u->bi_ctime = inode_u->bi_ctime = now; 317 dir_u->bi_nlink -= is_subdir_for_nlink(inode_u); 318 319 ret = bch2_hash_delete_at(trans, bch2_dirent_hash_desc, 320 &dir_hash, &dirent_iter, 321 BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE) ?: 322 bch2_inode_write(trans, &dir_iter, dir_u) ?: 323 bch2_inode_write(trans, &inode_iter, inode_u); 324 err: 325 bch2_trans_iter_exit(trans, &inode_iter); 326 bch2_trans_iter_exit(trans, &dirent_iter); 327 bch2_trans_iter_exit(trans, &dir_iter); 328 return ret; 329 } 330 331 bool bch2_reinherit_attrs(struct bch_inode_unpacked *dst_u, 332 struct bch_inode_unpacked *src_u) 333 { 334 u64 src, dst; 335 unsigned id; 336 bool ret = false; 337 338 for (id = 0; id < Inode_opt_nr; id++) { 339 /* Skip attributes that were explicitly set on this inode */ 340 if (dst_u->bi_fields_set & (1 << id)) 341 continue; 342 343 src = bch2_inode_opt_get(src_u, id); 344 dst = bch2_inode_opt_get(dst_u, id); 345 346 if (src == dst) 347 continue; 348 349 bch2_inode_opt_set(dst_u, id, src); 350 ret = true; 351 } 352 353 return ret; 354 } 355 356 int bch2_rename_trans(struct btree_trans *trans, 357 subvol_inum src_dir, struct bch_inode_unpacked *src_dir_u, 358 subvol_inum dst_dir, struct bch_inode_unpacked *dst_dir_u, 359 struct bch_inode_unpacked *src_inode_u, 360 struct bch_inode_unpacked *dst_inode_u, 361 const struct qstr *src_name, 362 const struct qstr *dst_name, 363 enum bch_rename_mode mode) 364 { 365 struct bch_fs *c = trans->c; 366 struct btree_iter src_dir_iter = { NULL }; 367 struct btree_iter dst_dir_iter = { NULL }; 368 struct btree_iter src_inode_iter = { NULL }; 369 struct btree_iter dst_inode_iter = { NULL }; 370 struct bch_hash_info src_hash, dst_hash; 371 subvol_inum src_inum, dst_inum; 372 u64 src_offset, dst_offset; 373 u64 now = bch2_current_time(c); 374 int ret; 375 376 ret = bch2_inode_peek(trans, &src_dir_iter, src_dir_u, src_dir, 377 BTREE_ITER_INTENT); 378 if (ret) 379 goto err; 380 381 src_hash = bch2_hash_info_init(c, src_dir_u); 382 383 if (dst_dir.inum != src_dir.inum || 384 dst_dir.subvol != src_dir.subvol) { 385 ret = bch2_inode_peek(trans, &dst_dir_iter, dst_dir_u, dst_dir, 386 BTREE_ITER_INTENT); 387 if (ret) 388 goto err; 389 390 dst_hash = bch2_hash_info_init(c, dst_dir_u); 391 } else { 392 dst_dir_u = src_dir_u; 393 dst_hash = src_hash; 394 } 395 396 ret = bch2_dirent_rename(trans, 397 src_dir, &src_hash, 398 dst_dir, &dst_hash, 399 src_name, &src_inum, &src_offset, 400 dst_name, &dst_inum, &dst_offset, 401 mode); 402 if (ret) 403 goto err; 404 405 ret = bch2_inode_peek(trans, &src_inode_iter, src_inode_u, src_inum, 406 BTREE_ITER_INTENT); 407 if (ret) 408 goto err; 409 410 if (dst_inum.inum) { 411 ret = bch2_inode_peek(trans, &dst_inode_iter, dst_inode_u, dst_inum, 412 BTREE_ITER_INTENT); 413 if (ret) 414 goto err; 415 } 416 417 if (c->sb.version >= bcachefs_metadata_version_inode_backpointers) { 418 src_inode_u->bi_dir = dst_dir_u->bi_inum; 419 src_inode_u->bi_dir_offset = dst_offset; 420 421 if (mode == BCH_RENAME_EXCHANGE) { 422 dst_inode_u->bi_dir = src_dir_u->bi_inum; 423 dst_inode_u->bi_dir_offset = src_offset; 424 } 425 426 if (mode == BCH_RENAME_OVERWRITE && 427 dst_inode_u->bi_dir == dst_dir_u->bi_inum && 428 dst_inode_u->bi_dir_offset == src_offset) { 429 dst_inode_u->bi_dir = 0; 430 dst_inode_u->bi_dir_offset = 0; 431 } 432 } 433 434 if (mode == BCH_RENAME_OVERWRITE) { 435 if (S_ISDIR(src_inode_u->bi_mode) != 436 S_ISDIR(dst_inode_u->bi_mode)) { 437 ret = -ENOTDIR; 438 goto err; 439 } 440 441 if (S_ISDIR(dst_inode_u->bi_mode) && 442 bch2_empty_dir_trans(trans, dst_inum)) { 443 ret = -ENOTEMPTY; 444 goto err; 445 } 446 } 447 448 if (bch2_reinherit_attrs(src_inode_u, dst_dir_u) && 449 S_ISDIR(src_inode_u->bi_mode)) { 450 ret = -EXDEV; 451 goto err; 452 } 453 454 if (mode == BCH_RENAME_EXCHANGE && 455 bch2_reinherit_attrs(dst_inode_u, src_dir_u) && 456 S_ISDIR(dst_inode_u->bi_mode)) { 457 ret = -EXDEV; 458 goto err; 459 } 460 461 if (is_subdir_for_nlink(src_inode_u)) { 462 src_dir_u->bi_nlink--; 463 dst_dir_u->bi_nlink++; 464 } 465 466 if (dst_inum.inum && is_subdir_for_nlink(dst_inode_u)) { 467 dst_dir_u->bi_nlink--; 468 src_dir_u->bi_nlink += mode == BCH_RENAME_EXCHANGE; 469 } 470 471 if (mode == BCH_RENAME_OVERWRITE) 472 bch2_inode_nlink_dec(trans, dst_inode_u); 473 474 src_dir_u->bi_mtime = now; 475 src_dir_u->bi_ctime = now; 476 477 if (src_dir.inum != dst_dir.inum) { 478 dst_dir_u->bi_mtime = now; 479 dst_dir_u->bi_ctime = now; 480 } 481 482 src_inode_u->bi_ctime = now; 483 484 if (dst_inum.inum) 485 dst_inode_u->bi_ctime = now; 486 487 ret = bch2_inode_write(trans, &src_dir_iter, src_dir_u) ?: 488 (src_dir.inum != dst_dir.inum 489 ? bch2_inode_write(trans, &dst_dir_iter, dst_dir_u) 490 : 0) ?: 491 bch2_inode_write(trans, &src_inode_iter, src_inode_u) ?: 492 (dst_inum.inum 493 ? bch2_inode_write(trans, &dst_inode_iter, dst_inode_u) 494 : 0); 495 err: 496 bch2_trans_iter_exit(trans, &dst_inode_iter); 497 bch2_trans_iter_exit(trans, &src_inode_iter); 498 bch2_trans_iter_exit(trans, &dst_dir_iter); 499 bch2_trans_iter_exit(trans, &src_dir_iter); 500 return ret; 501 } 502