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