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