1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/hpfs/namei.c 4 * 5 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999 6 * 7 * adding & removing files & directories 8 */ 9 #include <linux/sched.h> 10 #include "hpfs_fn.h" 11 12 static void hpfs_update_directory_times(struct inode *dir) 13 { 14 time64_t t = local_to_gmt(dir->i_sb, local_get_seconds(dir->i_sb)); 15 if (t == dir->i_mtime.tv_sec && 16 t == dir->i_ctime.tv_sec) 17 return; 18 dir->i_mtime.tv_sec = dir->i_ctime.tv_sec = t; 19 dir->i_mtime.tv_nsec = dir->i_ctime.tv_nsec = 0; 20 hpfs_write_inode_nolock(dir); 21 } 22 23 static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 24 { 25 const unsigned char *name = dentry->d_name.name; 26 unsigned len = dentry->d_name.len; 27 struct quad_buffer_head qbh0; 28 struct buffer_head *bh; 29 struct hpfs_dirent *de; 30 struct fnode *fnode; 31 struct dnode *dnode; 32 struct inode *result; 33 fnode_secno fno; 34 dnode_secno dno; 35 int r; 36 struct hpfs_dirent dee; 37 int err; 38 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; 39 hpfs_lock(dir->i_sb); 40 err = -ENOSPC; 41 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); 42 if (!fnode) 43 goto bail; 44 dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0); 45 if (!dnode) 46 goto bail1; 47 memset(&dee, 0, sizeof dee); 48 dee.directory = 1; 49 if (!(mode & 0222)) dee.read_only = 1; 50 /*dee.archive = 0;*/ 51 dee.hidden = name[0] == '.'; 52 dee.fnode = cpu_to_le32(fno); 53 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); 54 result = new_inode(dir->i_sb); 55 if (!result) 56 goto bail2; 57 hpfs_init_inode(result); 58 result->i_ino = fno; 59 hpfs_i(result)->i_parent_dir = dir->i_ino; 60 hpfs_i(result)->i_dno = dno; 61 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); 62 result->i_ctime.tv_nsec = 0; 63 result->i_mtime.tv_nsec = 0; 64 result->i_atime.tv_nsec = 0; 65 hpfs_i(result)->i_ea_size = 0; 66 result->i_mode |= S_IFDIR; 67 result->i_op = &hpfs_dir_iops; 68 result->i_fop = &hpfs_dir_ops; 69 result->i_blocks = 4; 70 result->i_size = 2048; 71 set_nlink(result, 2); 72 if (dee.read_only) 73 result->i_mode &= ~0222; 74 75 r = hpfs_add_dirent(dir, name, len, &dee); 76 if (r == 1) 77 goto bail3; 78 if (r == -1) { 79 err = -EEXIST; 80 goto bail3; 81 } 82 fnode->len = len; 83 memcpy(fnode->name, name, len > 15 ? 15 : len); 84 fnode->up = cpu_to_le32(dir->i_ino); 85 fnode->flags |= FNODE_dir; 86 fnode->btree.n_free_nodes = 7; 87 fnode->btree.n_used_nodes = 1; 88 fnode->btree.first_free = cpu_to_le16(0x14); 89 fnode->u.external[0].disk_secno = cpu_to_le32(dno); 90 fnode->u.external[0].file_secno = cpu_to_le32(-1); 91 dnode->root_dnode = 1; 92 dnode->up = cpu_to_le32(fno); 93 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0); 94 de->creation_date = de->write_date = de->read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); 95 if (!(mode & 0222)) de->read_only = 1; 96 de->first = de->directory = 1; 97 /*de->hidden = de->system = 0;*/ 98 de->fnode = cpu_to_le32(fno); 99 mark_buffer_dirty(bh); 100 brelse(bh); 101 hpfs_mark_4buffers_dirty(&qbh0); 102 hpfs_brelse4(&qbh0); 103 inc_nlink(dir); 104 insert_inode_hash(result); 105 106 if (!uid_eq(result->i_uid, current_fsuid()) || 107 !gid_eq(result->i_gid, current_fsgid()) || 108 result->i_mode != (mode | S_IFDIR)) { 109 result->i_uid = current_fsuid(); 110 result->i_gid = current_fsgid(); 111 result->i_mode = mode | S_IFDIR; 112 hpfs_write_inode_nolock(result); 113 } 114 hpfs_update_directory_times(dir); 115 d_instantiate(dentry, result); 116 hpfs_unlock(dir->i_sb); 117 return 0; 118 bail3: 119 iput(result); 120 bail2: 121 hpfs_brelse4(&qbh0); 122 hpfs_free_dnode(dir->i_sb, dno); 123 bail1: 124 brelse(bh); 125 hpfs_free_sectors(dir->i_sb, fno, 1); 126 bail: 127 hpfs_unlock(dir->i_sb); 128 return err; 129 } 130 131 static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl) 132 { 133 const unsigned char *name = dentry->d_name.name; 134 unsigned len = dentry->d_name.len; 135 struct inode *result = NULL; 136 struct buffer_head *bh; 137 struct fnode *fnode; 138 fnode_secno fno; 139 int r; 140 struct hpfs_dirent dee; 141 int err; 142 if ((err = hpfs_chk_name(name, &len))) 143 return err==-ENOENT ? -EINVAL : err; 144 hpfs_lock(dir->i_sb); 145 err = -ENOSPC; 146 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); 147 if (!fnode) 148 goto bail; 149 memset(&dee, 0, sizeof dee); 150 if (!(mode & 0222)) dee.read_only = 1; 151 dee.archive = 1; 152 dee.hidden = name[0] == '.'; 153 dee.fnode = cpu_to_le32(fno); 154 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); 155 156 result = new_inode(dir->i_sb); 157 if (!result) 158 goto bail1; 159 160 hpfs_init_inode(result); 161 result->i_ino = fno; 162 result->i_mode |= S_IFREG; 163 result->i_mode &= ~0111; 164 result->i_op = &hpfs_file_iops; 165 result->i_fop = &hpfs_file_ops; 166 set_nlink(result, 1); 167 hpfs_i(result)->i_parent_dir = dir->i_ino; 168 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); 169 result->i_ctime.tv_nsec = 0; 170 result->i_mtime.tv_nsec = 0; 171 result->i_atime.tv_nsec = 0; 172 hpfs_i(result)->i_ea_size = 0; 173 if (dee.read_only) 174 result->i_mode &= ~0222; 175 result->i_blocks = 1; 176 result->i_size = 0; 177 result->i_data.a_ops = &hpfs_aops; 178 hpfs_i(result)->mmu_private = 0; 179 180 r = hpfs_add_dirent(dir, name, len, &dee); 181 if (r == 1) 182 goto bail2; 183 if (r == -1) { 184 err = -EEXIST; 185 goto bail2; 186 } 187 fnode->len = len; 188 memcpy(fnode->name, name, len > 15 ? 15 : len); 189 fnode->up = cpu_to_le32(dir->i_ino); 190 mark_buffer_dirty(bh); 191 brelse(bh); 192 193 insert_inode_hash(result); 194 195 if (!uid_eq(result->i_uid, current_fsuid()) || 196 !gid_eq(result->i_gid, current_fsgid()) || 197 result->i_mode != (mode | S_IFREG)) { 198 result->i_uid = current_fsuid(); 199 result->i_gid = current_fsgid(); 200 result->i_mode = mode | S_IFREG; 201 hpfs_write_inode_nolock(result); 202 } 203 hpfs_update_directory_times(dir); 204 d_instantiate(dentry, result); 205 hpfs_unlock(dir->i_sb); 206 return 0; 207 208 bail2: 209 iput(result); 210 bail1: 211 brelse(bh); 212 hpfs_free_sectors(dir->i_sb, fno, 1); 213 bail: 214 hpfs_unlock(dir->i_sb); 215 return err; 216 } 217 218 static int hpfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev) 219 { 220 const unsigned char *name = dentry->d_name.name; 221 unsigned len = dentry->d_name.len; 222 struct buffer_head *bh; 223 struct fnode *fnode; 224 fnode_secno fno; 225 int r; 226 struct hpfs_dirent dee; 227 struct inode *result = NULL; 228 int err; 229 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; 230 if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM; 231 hpfs_lock(dir->i_sb); 232 err = -ENOSPC; 233 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); 234 if (!fnode) 235 goto bail; 236 memset(&dee, 0, sizeof dee); 237 if (!(mode & 0222)) dee.read_only = 1; 238 dee.archive = 1; 239 dee.hidden = name[0] == '.'; 240 dee.fnode = cpu_to_le32(fno); 241 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); 242 243 result = new_inode(dir->i_sb); 244 if (!result) 245 goto bail1; 246 247 hpfs_init_inode(result); 248 result->i_ino = fno; 249 hpfs_i(result)->i_parent_dir = dir->i_ino; 250 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); 251 result->i_ctime.tv_nsec = 0; 252 result->i_mtime.tv_nsec = 0; 253 result->i_atime.tv_nsec = 0; 254 hpfs_i(result)->i_ea_size = 0; 255 result->i_uid = current_fsuid(); 256 result->i_gid = current_fsgid(); 257 set_nlink(result, 1); 258 result->i_size = 0; 259 result->i_blocks = 1; 260 init_special_inode(result, mode, rdev); 261 262 r = hpfs_add_dirent(dir, name, len, &dee); 263 if (r == 1) 264 goto bail2; 265 if (r == -1) { 266 err = -EEXIST; 267 goto bail2; 268 } 269 fnode->len = len; 270 memcpy(fnode->name, name, len > 15 ? 15 : len); 271 fnode->up = cpu_to_le32(dir->i_ino); 272 mark_buffer_dirty(bh); 273 274 insert_inode_hash(result); 275 276 hpfs_write_inode_nolock(result); 277 hpfs_update_directory_times(dir); 278 d_instantiate(dentry, result); 279 brelse(bh); 280 hpfs_unlock(dir->i_sb); 281 return 0; 282 bail2: 283 iput(result); 284 bail1: 285 brelse(bh); 286 hpfs_free_sectors(dir->i_sb, fno, 1); 287 bail: 288 hpfs_unlock(dir->i_sb); 289 return err; 290 } 291 292 static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink) 293 { 294 const unsigned char *name = dentry->d_name.name; 295 unsigned len = dentry->d_name.len; 296 struct buffer_head *bh; 297 struct fnode *fnode; 298 fnode_secno fno; 299 int r; 300 struct hpfs_dirent dee; 301 struct inode *result; 302 int err; 303 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; 304 hpfs_lock(dir->i_sb); 305 if (hpfs_sb(dir->i_sb)->sb_eas < 2) { 306 hpfs_unlock(dir->i_sb); 307 return -EPERM; 308 } 309 err = -ENOSPC; 310 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); 311 if (!fnode) 312 goto bail; 313 memset(&dee, 0, sizeof dee); 314 dee.archive = 1; 315 dee.hidden = name[0] == '.'; 316 dee.fnode = cpu_to_le32(fno); 317 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); 318 319 result = new_inode(dir->i_sb); 320 if (!result) 321 goto bail1; 322 result->i_ino = fno; 323 hpfs_init_inode(result); 324 hpfs_i(result)->i_parent_dir = dir->i_ino; 325 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); 326 result->i_ctime.tv_nsec = 0; 327 result->i_mtime.tv_nsec = 0; 328 result->i_atime.tv_nsec = 0; 329 hpfs_i(result)->i_ea_size = 0; 330 result->i_mode = S_IFLNK | 0777; 331 result->i_uid = current_fsuid(); 332 result->i_gid = current_fsgid(); 333 result->i_blocks = 1; 334 set_nlink(result, 1); 335 result->i_size = strlen(symlink); 336 inode_nohighmem(result); 337 result->i_op = &page_symlink_inode_operations; 338 result->i_data.a_ops = &hpfs_symlink_aops; 339 340 r = hpfs_add_dirent(dir, name, len, &dee); 341 if (r == 1) 342 goto bail2; 343 if (r == -1) { 344 err = -EEXIST; 345 goto bail2; 346 } 347 fnode->len = len; 348 memcpy(fnode->name, name, len > 15 ? 15 : len); 349 fnode->up = cpu_to_le32(dir->i_ino); 350 hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink)); 351 mark_buffer_dirty(bh); 352 brelse(bh); 353 354 insert_inode_hash(result); 355 356 hpfs_write_inode_nolock(result); 357 hpfs_update_directory_times(dir); 358 d_instantiate(dentry, result); 359 hpfs_unlock(dir->i_sb); 360 return 0; 361 bail2: 362 iput(result); 363 bail1: 364 brelse(bh); 365 hpfs_free_sectors(dir->i_sb, fno, 1); 366 bail: 367 hpfs_unlock(dir->i_sb); 368 return err; 369 } 370 371 static int hpfs_unlink(struct inode *dir, struct dentry *dentry) 372 { 373 const unsigned char *name = dentry->d_name.name; 374 unsigned len = dentry->d_name.len; 375 struct quad_buffer_head qbh; 376 struct hpfs_dirent *de; 377 struct inode *inode = d_inode(dentry); 378 dnode_secno dno; 379 int r; 380 int err; 381 382 hpfs_lock(dir->i_sb); 383 hpfs_adjust_length(name, &len); 384 385 err = -ENOENT; 386 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh); 387 if (!de) 388 goto out; 389 390 err = -EPERM; 391 if (de->first) 392 goto out1; 393 394 err = -EISDIR; 395 if (de->directory) 396 goto out1; 397 398 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1); 399 switch (r) { 400 case 1: 401 hpfs_error(dir->i_sb, "there was error when removing dirent"); 402 err = -EFSERROR; 403 break; 404 case 2: /* no space for deleting */ 405 err = -ENOSPC; 406 break; 407 default: 408 drop_nlink(inode); 409 err = 0; 410 } 411 goto out; 412 413 out1: 414 hpfs_brelse4(&qbh); 415 out: 416 if (!err) 417 hpfs_update_directory_times(dir); 418 hpfs_unlock(dir->i_sb); 419 return err; 420 } 421 422 static int hpfs_rmdir(struct inode *dir, struct dentry *dentry) 423 { 424 const unsigned char *name = dentry->d_name.name; 425 unsigned len = dentry->d_name.len; 426 struct quad_buffer_head qbh; 427 struct hpfs_dirent *de; 428 struct inode *inode = d_inode(dentry); 429 dnode_secno dno; 430 int n_items = 0; 431 int err; 432 int r; 433 434 hpfs_adjust_length(name, &len); 435 hpfs_lock(dir->i_sb); 436 err = -ENOENT; 437 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh); 438 if (!de) 439 goto out; 440 441 err = -EPERM; 442 if (de->first) 443 goto out1; 444 445 err = -ENOTDIR; 446 if (!de->directory) 447 goto out1; 448 449 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items); 450 err = -ENOTEMPTY; 451 if (n_items) 452 goto out1; 453 454 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1); 455 switch (r) { 456 case 1: 457 hpfs_error(dir->i_sb, "there was error when removing dirent"); 458 err = -EFSERROR; 459 break; 460 case 2: 461 err = -ENOSPC; 462 break; 463 default: 464 drop_nlink(dir); 465 clear_nlink(inode); 466 err = 0; 467 } 468 goto out; 469 out1: 470 hpfs_brelse4(&qbh); 471 out: 472 if (!err) 473 hpfs_update_directory_times(dir); 474 hpfs_unlock(dir->i_sb); 475 return err; 476 } 477 478 static int hpfs_symlink_readpage(struct file *file, struct page *page) 479 { 480 char *link = page_address(page); 481 struct inode *i = page->mapping->host; 482 struct fnode *fnode; 483 struct buffer_head *bh; 484 int err; 485 486 err = -EIO; 487 hpfs_lock(i->i_sb); 488 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) 489 goto fail; 490 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE); 491 brelse(bh); 492 if (err) 493 goto fail; 494 hpfs_unlock(i->i_sb); 495 SetPageUptodate(page); 496 unlock_page(page); 497 return 0; 498 499 fail: 500 hpfs_unlock(i->i_sb); 501 SetPageError(page); 502 unlock_page(page); 503 return err; 504 } 505 506 const struct address_space_operations hpfs_symlink_aops = { 507 .readpage = hpfs_symlink_readpage 508 }; 509 510 static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry, 511 struct inode *new_dir, struct dentry *new_dentry, 512 unsigned int flags) 513 { 514 const unsigned char *old_name = old_dentry->d_name.name; 515 unsigned old_len = old_dentry->d_name.len; 516 const unsigned char *new_name = new_dentry->d_name.name; 517 unsigned new_len = new_dentry->d_name.len; 518 struct inode *i = d_inode(old_dentry); 519 struct inode *new_inode = d_inode(new_dentry); 520 struct quad_buffer_head qbh, qbh1; 521 struct hpfs_dirent *dep, *nde; 522 struct hpfs_dirent de; 523 dnode_secno dno; 524 int r; 525 struct buffer_head *bh; 526 struct fnode *fnode; 527 int err; 528 529 if (flags & ~RENAME_NOREPLACE) 530 return -EINVAL; 531 532 if ((err = hpfs_chk_name(new_name, &new_len))) return err; 533 err = 0; 534 hpfs_adjust_length(old_name, &old_len); 535 536 hpfs_lock(i->i_sb); 537 /* order doesn't matter, due to VFS exclusion */ 538 539 /* Erm? Moving over the empty non-busy directory is perfectly legal */ 540 if (new_inode && S_ISDIR(new_inode->i_mode)) { 541 err = -EINVAL; 542 goto end1; 543 } 544 545 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 546 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed"); 547 err = -ENOENT; 548 goto end1; 549 } 550 copy_de(&de, dep); 551 de.hidden = new_name[0] == '.'; 552 553 if (new_inode) { 554 int r; 555 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) { 556 if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) { 557 clear_nlink(new_inode); 558 copy_de(nde, &de); 559 memcpy(nde->name, new_name, new_len); 560 hpfs_mark_4buffers_dirty(&qbh1); 561 hpfs_brelse4(&qbh1); 562 goto end; 563 } 564 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent"); 565 err = -EFSERROR; 566 goto end1; 567 } 568 err = -ENOSPC; 569 goto end1; 570 } 571 572 if (new_dir == old_dir) hpfs_brelse4(&qbh); 573 574 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de))) { 575 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!"); 576 err = r == 1 ? -ENOSPC : -EFSERROR; 577 if (new_dir != old_dir) hpfs_brelse4(&qbh); 578 goto end1; 579 } 580 581 if (new_dir == old_dir) 582 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 583 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2"); 584 err = -ENOENT; 585 goto end1; 586 } 587 588 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) { 589 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent"); 590 err = r == 2 ? -ENOSPC : -EFSERROR; 591 goto end1; 592 } 593 594 end: 595 hpfs_i(i)->i_parent_dir = new_dir->i_ino; 596 if (S_ISDIR(i->i_mode)) { 597 inc_nlink(new_dir); 598 drop_nlink(old_dir); 599 } 600 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) { 601 fnode->up = cpu_to_le32(new_dir->i_ino); 602 fnode->len = new_len; 603 memcpy(fnode->name, new_name, new_len>15?15:new_len); 604 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len); 605 mark_buffer_dirty(bh); 606 brelse(bh); 607 } 608 end1: 609 if (!err) { 610 hpfs_update_directory_times(old_dir); 611 hpfs_update_directory_times(new_dir); 612 } 613 hpfs_unlock(i->i_sb); 614 return err; 615 } 616 617 const struct inode_operations hpfs_dir_iops = 618 { 619 .create = hpfs_create, 620 .lookup = hpfs_lookup, 621 .unlink = hpfs_unlink, 622 .symlink = hpfs_symlink, 623 .mkdir = hpfs_mkdir, 624 .rmdir = hpfs_rmdir, 625 .mknod = hpfs_mknod, 626 .rename = hpfs_rename, 627 .setattr = hpfs_setattr, 628 }; 629