1/* 2 * inode.c 3 * 4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke 5 * Copyright (C) 1997 by Volker Lendecke 6 * 7 * Please add a note about your changes to smbfs in the ChangeLog file. 8 */ 9 10#include <linux/module.h> 11#include <linux/time.h> 12#include <linux/kernel.h> 13#include <linux/mm.h> 14#include <linux/string.h> 15#include <linux/stat.h> 16#include <linux/errno.h> 17#include <linux/slab.h> 18#include <linux/init.h> 19#include <linux/file.h> 20#include <linux/dcache.h> 21#include <linux/smp_lock.h> 22#include <linux/nls.h> 23#include <linux/seq_file.h> 24#include <linux/mount.h> 25#include <linux/net.h> 26#include <linux/vfs.h> 27#include <linux/highuid.h> 28#include <linux/sched.h> 29#include <linux/smb_fs.h> 30#include <linux/smbno.h> 31#include <linux/smb_mount.h> 32 33#include <asm/system.h> 34#include <asm/uaccess.h> 35 36#include "smb_debug.h" 37#include "getopt.h" 38#include "proto.h" 39 40/* Always pick a default string */ 41#ifdef CONFIG_SMB_NLS_REMOTE 42#define SMB_NLS_REMOTE CONFIG_SMB_NLS_REMOTE 43#else 44#define SMB_NLS_REMOTE "" 45#endif 46 47#define SMB_TTL_DEFAULT 1000 48 49static void smb_evict_inode(struct inode *); 50static void smb_put_super(struct super_block *); 51static int smb_statfs(struct dentry *, struct kstatfs *); 52static int smb_show_options(struct seq_file *, struct vfsmount *); 53 54static struct kmem_cache *smb_inode_cachep; 55 56static struct inode *smb_alloc_inode(struct super_block *sb) 57{ 58 struct smb_inode_info *ei; 59 ei = (struct smb_inode_info *)kmem_cache_alloc(smb_inode_cachep, GFP_KERNEL); 60 if (!ei) 61 return NULL; 62 return &ei->vfs_inode; 63} 64 65static void smb_destroy_inode(struct inode *inode) 66{ 67 kmem_cache_free(smb_inode_cachep, SMB_I(inode)); 68} 69 70static void init_once(void *foo) 71{ 72 struct smb_inode_info *ei = (struct smb_inode_info *) foo; 73 74 inode_init_once(&ei->vfs_inode); 75} 76 77static int init_inodecache(void) 78{ 79 smb_inode_cachep = kmem_cache_create("smb_inode_cache", 80 sizeof(struct smb_inode_info), 81 0, (SLAB_RECLAIM_ACCOUNT| 82 SLAB_MEM_SPREAD), 83 init_once); 84 if (smb_inode_cachep == NULL) 85 return -ENOMEM; 86 return 0; 87} 88 89static void destroy_inodecache(void) 90{ 91 kmem_cache_destroy(smb_inode_cachep); 92} 93 94static int smb_remount(struct super_block *sb, int *flags, char *data) 95{ 96 *flags |= MS_NODIRATIME; 97 return 0; 98} 99 100static const struct super_operations smb_sops = 101{ 102 .alloc_inode = smb_alloc_inode, 103 .destroy_inode = smb_destroy_inode, 104 .drop_inode = generic_delete_inode, 105 .evict_inode = smb_evict_inode, 106 .put_super = smb_put_super, 107 .statfs = smb_statfs, 108 .show_options = smb_show_options, 109 .remount_fs = smb_remount, 110}; 111 112 113/* We are always generating a new inode here */ 114struct inode * 115smb_iget(struct super_block *sb, struct smb_fattr *fattr) 116{ 117 struct smb_sb_info *server = SMB_SB(sb); 118 struct inode *result; 119 120 DEBUG1("smb_iget: %p\n", fattr); 121 122 result = new_inode(sb); 123 if (!result) 124 return result; 125 result->i_ino = fattr->f_ino; 126 SMB_I(result)->open = 0; 127 SMB_I(result)->fileid = 0; 128 SMB_I(result)->access = 0; 129 SMB_I(result)->flags = 0; 130 SMB_I(result)->closed = 0; 131 SMB_I(result)->openers = 0; 132 smb_set_inode_attr(result, fattr); 133 if (S_ISREG(result->i_mode)) { 134 result->i_op = &smb_file_inode_operations; 135 result->i_fop = &smb_file_operations; 136 result->i_data.a_ops = &smb_file_aops; 137 } else if (S_ISDIR(result->i_mode)) { 138 if (server->opt.capabilities & SMB_CAP_UNIX) 139 result->i_op = &smb_dir_inode_operations_unix; 140 else 141 result->i_op = &smb_dir_inode_operations; 142 result->i_fop = &smb_dir_operations; 143 } else if (S_ISLNK(result->i_mode)) { 144 result->i_op = &smb_link_inode_operations; 145 } else { 146 init_special_inode(result, result->i_mode, fattr->f_rdev); 147 } 148 insert_inode_hash(result); 149 return result; 150} 151 152/* 153 * Copy the inode data to a smb_fattr structure. 154 */ 155void 156smb_get_inode_attr(struct inode *inode, struct smb_fattr *fattr) 157{ 158 memset(fattr, 0, sizeof(struct smb_fattr)); 159 fattr->f_mode = inode->i_mode; 160 fattr->f_nlink = inode->i_nlink; 161 fattr->f_ino = inode->i_ino; 162 fattr->f_uid = inode->i_uid; 163 fattr->f_gid = inode->i_gid; 164 fattr->f_size = inode->i_size; 165 fattr->f_mtime = inode->i_mtime; 166 fattr->f_ctime = inode->i_ctime; 167 fattr->f_atime = inode->i_atime; 168 fattr->f_blocks = inode->i_blocks; 169 170 fattr->attr = SMB_I(inode)->attr; 171 /* 172 * Keep the attributes in sync with the inode permissions. 173 */ 174 if (fattr->f_mode & S_IWUSR) 175 fattr->attr &= ~aRONLY; 176 else 177 fattr->attr |= aRONLY; 178} 179 180/* 181 * Update the inode, possibly causing it to invalidate its pages if mtime/size 182 * is different from last time. 183 */ 184void 185smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr) 186{ 187 struct smb_inode_info *ei = SMB_I(inode); 188 189 /* 190 * A size change should have a different mtime, or same mtime 191 * but different size. 192 */ 193 time_t last_time = inode->i_mtime.tv_sec; 194 loff_t last_sz = inode->i_size; 195 196 inode->i_mode = fattr->f_mode; 197 inode->i_nlink = fattr->f_nlink; 198 inode->i_uid = fattr->f_uid; 199 inode->i_gid = fattr->f_gid; 200 inode->i_ctime = fattr->f_ctime; 201 inode->i_blocks = fattr->f_blocks; 202 inode->i_size = fattr->f_size; 203 inode->i_mtime = fattr->f_mtime; 204 inode->i_atime = fattr->f_atime; 205 ei->attr = fattr->attr; 206 207 /* 208 * Update the "last time refreshed" field for revalidation. 209 */ 210 ei->oldmtime = jiffies; 211 212 if (inode->i_mtime.tv_sec != last_time || inode->i_size != last_sz) { 213 VERBOSE("%ld changed, old=%ld, new=%ld, oz=%ld, nz=%ld\n", 214 inode->i_ino, 215 (long) last_time, (long) inode->i_mtime.tv_sec, 216 (long) last_sz, (long) inode->i_size); 217 218 if (!S_ISDIR(inode->i_mode)) 219 invalidate_remote_inode(inode); 220 } 221} 222 223/* 224 * This is called if the connection has gone bad ... 225 * try to kill off all the current inodes. 226 */ 227void 228smb_invalidate_inodes(struct smb_sb_info *server) 229{ 230 VERBOSE("\n"); 231 shrink_dcache_sb(SB_of(server)); 232 invalidate_inodes(SB_of(server)); 233} 234 235/* 236 * This is called to update the inode attributes after 237 * we've made changes to a file or directory. 238 */ 239static int 240smb_refresh_inode(struct dentry *dentry) 241{ 242 struct inode *inode = dentry->d_inode; 243 int error; 244 struct smb_fattr fattr; 245 246 error = smb_proc_getattr(dentry, &fattr); 247 if (!error) { 248 smb_renew_times(dentry); 249 /* 250 * Check whether the type part of the mode changed, 251 * and don't update the attributes if it did. 252 * 253 * And don't dick with the root inode 254 */ 255 if (inode->i_ino == 2) 256 return error; 257 if (S_ISLNK(inode->i_mode)) 258 return error; /* VFS will deal with it */ 259 260 if ((inode->i_mode & S_IFMT) == (fattr.f_mode & S_IFMT)) { 261 smb_set_inode_attr(inode, &fattr); 262 } else { 263 /* 264 * Big trouble! The inode has become a new object, 265 * so any operations attempted on it are invalid. 266 * 267 * To limit damage, mark the inode as bad so that 268 * subsequent lookup validations will fail. 269 */ 270 PARANOIA("%s/%s changed mode, %07o to %07o\n", 271 DENTRY_PATH(dentry), 272 inode->i_mode, fattr.f_mode); 273 274 fattr.f_mode = inode->i_mode; /* save mode */ 275 make_bad_inode(inode); 276 inode->i_mode = fattr.f_mode; /* restore mode */ 277 /* 278 * No need to worry about unhashing the dentry: the 279 * lookup validation will see that the inode is bad. 280 * But we do want to invalidate the caches ... 281 */ 282 if (!S_ISDIR(inode->i_mode)) 283 invalidate_remote_inode(inode); 284 else 285 smb_invalid_dir_cache(inode); 286 error = -EIO; 287 } 288 } 289 return error; 290} 291 292/* 293 * This is called when we want to check whether the inode 294 * has changed on the server. If it has changed, we must 295 * invalidate our local caches. 296 */ 297int 298smb_revalidate_inode(struct dentry *dentry) 299{ 300 struct smb_sb_info *s = server_from_dentry(dentry); 301 struct inode *inode = dentry->d_inode; 302 int error = 0; 303 304 DEBUG1("smb_revalidate_inode\n"); 305 lock_kernel(); 306 307 /* 308 * Check whether we've recently refreshed the inode. 309 */ 310 if (time_before(jiffies, SMB_I(inode)->oldmtime + SMB_MAX_AGE(s))) { 311 VERBOSE("up-to-date, ino=%ld, jiffies=%lu, oldtime=%lu\n", 312 inode->i_ino, jiffies, SMB_I(inode)->oldmtime); 313 goto out; 314 } 315 316 error = smb_refresh_inode(dentry); 317out: 318 unlock_kernel(); 319 return error; 320} 321 322/* 323 * This routine is called when i_nlink == 0 and i_count goes to 0. 324 * All blocking cleanup operations need to go here to avoid races. 325 */ 326static void 327smb_evict_inode(struct inode *ino) 328{ 329 DEBUG1("ino=%ld\n", ino->i_ino); 330 truncate_inode_pages(&ino->i_data, 0); 331 end_writeback(ino); 332 lock_kernel(); 333 if (smb_close(ino)) 334 PARANOIA("could not close inode %ld\n", ino->i_ino); 335 unlock_kernel(); 336} 337 338static struct option opts[] = { 339 { "version", 0, 'v' }, 340 { "win95", SMB_MOUNT_WIN95, 1 }, 341 { "oldattr", SMB_MOUNT_OLDATTR, 1 }, 342 { "dirattr", SMB_MOUNT_DIRATTR, 1 }, 343 { "case", SMB_MOUNT_CASE, 1 }, 344 { "uid", 0, 'u' }, 345 { "gid", 0, 'g' }, 346 { "file_mode", 0, 'f' }, 347 { "dir_mode", 0, 'd' }, 348 { "iocharset", 0, 'i' }, 349 { "codepage", 0, 'c' }, 350 { "ttl", 0, 't' }, 351 { NULL, 0, 0} 352}; 353 354static int 355parse_options(struct smb_mount_data_kernel *mnt, char *options) 356{ 357 int c; 358 unsigned long flags; 359 unsigned long value; 360 char *optarg; 361 char *optopt; 362 363 flags = 0; 364 while ( (c = smb_getopt("smbfs", &options, opts, 365 &optopt, &optarg, &flags, &value)) > 0) { 366 367 VERBOSE("'%s' -> '%s'\n", optopt, optarg ? optarg : "<none>"); 368 switch (c) { 369 case 1: 370 /* got a "flag" option */ 371 break; 372 case 'v': 373 if (value != SMB_MOUNT_VERSION) { 374 printk ("smbfs: Bad mount version %ld, expected %d\n", 375 value, SMB_MOUNT_VERSION); 376 return 0; 377 } 378 mnt->version = value; 379 break; 380 case 'u': 381 mnt->uid = value; 382 flags |= SMB_MOUNT_UID; 383 break; 384 case 'g': 385 mnt->gid = value; 386 flags |= SMB_MOUNT_GID; 387 break; 388 case 'f': 389 mnt->file_mode = (value & S_IRWXUGO) | S_IFREG; 390 flags |= SMB_MOUNT_FMODE; 391 break; 392 case 'd': 393 mnt->dir_mode = (value & S_IRWXUGO) | S_IFDIR; 394 flags |= SMB_MOUNT_DMODE; 395 break; 396 case 'i': 397 strlcpy(mnt->codepage.local_name, optarg, 398 SMB_NLS_MAXNAMELEN); 399 break; 400 case 'c': 401 strlcpy(mnt->codepage.remote_name, optarg, 402 SMB_NLS_MAXNAMELEN); 403 break; 404 case 't': 405 mnt->ttl = value; 406 break; 407 default: 408 printk ("smbfs: Unrecognized mount option %s\n", 409 optopt); 410 return -1; 411 } 412 } 413 mnt->flags = flags; 414 return c; 415} 416 417/* 418 * smb_show_options() is for displaying mount options in /proc/mounts. 419 * It tries to avoid showing settings that were not changed from their 420 * defaults. 421 */ 422static int 423smb_show_options(struct seq_file *s, struct vfsmount *m) 424{ 425 struct smb_mount_data_kernel *mnt = SMB_SB(m->mnt_sb)->mnt; 426 int i; 427 428 for (i = 0; opts[i].name != NULL; i++) 429 if (mnt->flags & opts[i].flag) 430 seq_printf(s, ",%s", opts[i].name); 431 432 if (mnt->flags & SMB_MOUNT_UID) 433 seq_printf(s, ",uid=%d", mnt->uid); 434 if (mnt->flags & SMB_MOUNT_GID) 435 seq_printf(s, ",gid=%d", mnt->gid); 436 if (mnt->mounted_uid != 0) 437 seq_printf(s, ",mounted_uid=%d", mnt->mounted_uid); 438 439 /* 440 * Defaults for file_mode and dir_mode are unknown to us; they 441 * depend on the current umask of the user doing the mount. 442 */ 443 if (mnt->flags & SMB_MOUNT_FMODE) 444 seq_printf(s, ",file_mode=%04o", mnt->file_mode & S_IRWXUGO); 445 if (mnt->flags & SMB_MOUNT_DMODE) 446 seq_printf(s, ",dir_mode=%04o", mnt->dir_mode & S_IRWXUGO); 447 448 if (strcmp(mnt->codepage.local_name, CONFIG_NLS_DEFAULT)) 449 seq_printf(s, ",iocharset=%s", mnt->codepage.local_name); 450 if (strcmp(mnt->codepage.remote_name, SMB_NLS_REMOTE)) 451 seq_printf(s, ",codepage=%s", mnt->codepage.remote_name); 452 453 if (mnt->ttl != SMB_TTL_DEFAULT) 454 seq_printf(s, ",ttl=%d", mnt->ttl); 455 456 return 0; 457} 458 459static void 460smb_unload_nls(struct smb_sb_info *server) 461{ 462 unload_nls(server->remote_nls); 463 unload_nls(server->local_nls); 464} 465 466static void 467smb_put_super(struct super_block *sb) 468{ 469 struct smb_sb_info *server = SMB_SB(sb); 470 471 lock_kernel(); 472 473 smb_lock_server(server); 474 server->state = CONN_INVALID; 475 smbiod_unregister_server(server); 476 477 smb_close_socket(server); 478 479 if (server->conn_pid) 480 kill_pid(server->conn_pid, SIGTERM, 1); 481 482 bdi_destroy(&server->bdi); 483 kfree(server->ops); 484 smb_unload_nls(server); 485 sb->s_fs_info = NULL; 486 smb_unlock_server(server); 487 put_pid(server->conn_pid); 488 kfree(server); 489 490 unlock_kernel(); 491} 492 493static int smb_fill_super(struct super_block *sb, void *raw_data, int silent) 494{ 495 struct smb_sb_info *server; 496 struct smb_mount_data_kernel *mnt; 497 struct smb_mount_data *oldmnt; 498 struct inode *root_inode; 499 struct smb_fattr root; 500 int ver; 501 void *mem; 502 static int warn_count; 503 504 if (warn_count < 5) { 505 warn_count++; 506 printk(KERN_EMERG "smbfs is deprecated and will be removed" 507 " from the 2.6.27 kernel. Please migrate to cifs\n"); 508 } 509 510 if (!raw_data) 511 goto out_no_data; 512 513 oldmnt = (struct smb_mount_data *) raw_data; 514 ver = oldmnt->version; 515 if (ver != SMB_MOUNT_OLDVERSION && cpu_to_be32(ver) != SMB_MOUNT_ASCII) 516 goto out_wrong_data; 517 518 sb->s_flags |= MS_NODIRATIME; 519 sb->s_blocksize = 1024; /* Eh... Is this correct? */ 520 sb->s_blocksize_bits = 10; 521 sb->s_magic = SMB_SUPER_MAGIC; 522 sb->s_op = &smb_sops; 523 sb->s_time_gran = 100; 524 525 server = kzalloc(sizeof(struct smb_sb_info), GFP_KERNEL); 526 if (!server) 527 goto out_no_server; 528 sb->s_fs_info = server; 529 530 if (bdi_setup_and_register(&server->bdi, "smbfs", BDI_CAP_MAP_COPY)) 531 goto out_bdi; 532 533 sb->s_bdi = &server->bdi; 534 535 server->super_block = sb; 536 server->mnt = NULL; 537 server->sock_file = NULL; 538 init_waitqueue_head(&server->conn_wq); 539 init_MUTEX(&server->sem); 540 INIT_LIST_HEAD(&server->entry); 541 INIT_LIST_HEAD(&server->xmitq); 542 INIT_LIST_HEAD(&server->recvq); 543 server->conn_error = 0; 544 server->conn_pid = NULL; 545 server->state = CONN_INVALID; /* no connection yet */ 546 server->generation = 0; 547 548 /* Allocate the global temp buffer and some superblock helper structs */ 549 VERBOSE("alloc chunk = %lu\n", sizeof(struct smb_ops) + 550 sizeof(struct smb_mount_data_kernel)); 551 mem = kmalloc(sizeof(struct smb_ops) + 552 sizeof(struct smb_mount_data_kernel), GFP_KERNEL); 553 if (!mem) 554 goto out_no_mem; 555 556 server->ops = mem; 557 smb_install_null_ops(server->ops); 558 server->mnt = mem + sizeof(struct smb_ops); 559 560 /* Setup NLS stuff */ 561 server->remote_nls = NULL; 562 server->local_nls = NULL; 563 564 mnt = server->mnt; 565 566 memset(mnt, 0, sizeof(struct smb_mount_data_kernel)); 567 strlcpy(mnt->codepage.local_name, CONFIG_NLS_DEFAULT, 568 SMB_NLS_MAXNAMELEN); 569 strlcpy(mnt->codepage.remote_name, SMB_NLS_REMOTE, 570 SMB_NLS_MAXNAMELEN); 571 572 mnt->ttl = SMB_TTL_DEFAULT; 573 if (ver == SMB_MOUNT_OLDVERSION) { 574 mnt->version = oldmnt->version; 575 576 SET_UID(mnt->uid, oldmnt->uid); 577 SET_GID(mnt->gid, oldmnt->gid); 578 579 mnt->file_mode = (oldmnt->file_mode & S_IRWXUGO) | S_IFREG; 580 mnt->dir_mode = (oldmnt->dir_mode & S_IRWXUGO) | S_IFDIR; 581 582 mnt->flags = (oldmnt->file_mode >> 9) | SMB_MOUNT_UID | 583 SMB_MOUNT_GID | SMB_MOUNT_FMODE | SMB_MOUNT_DMODE; 584 } else { 585 mnt->file_mode = S_IRWXU | S_IRGRP | S_IXGRP | 586 S_IROTH | S_IXOTH | S_IFREG; 587 mnt->dir_mode = S_IRWXU | S_IRGRP | S_IXGRP | 588 S_IROTH | S_IXOTH | S_IFDIR; 589 if (parse_options(mnt, raw_data)) 590 goto out_bad_option; 591 } 592 mnt->mounted_uid = current_uid(); 593 smb_setcodepage(server, &mnt->codepage); 594 595 /* 596 * Display the enabled options 597 * Note: smb_proc_getattr uses these in 2.4 (but was changed in 2.2) 598 */ 599 if (mnt->flags & SMB_MOUNT_OLDATTR) 600 printk("SMBFS: Using core getattr (Win 95 speedup)\n"); 601 else if (mnt->flags & SMB_MOUNT_DIRATTR) 602 printk("SMBFS: Using dir ff getattr\n"); 603 604 if (smbiod_register_server(server) < 0) { 605 printk(KERN_ERR "smbfs: failed to start smbiod\n"); 606 goto out_no_smbiod; 607 } 608 609 /* 610 * Keep the super block locked while we get the root inode. 611 */ 612 smb_init_root_dirent(server, &root, sb); 613 root_inode = smb_iget(sb, &root); 614 if (!root_inode) 615 goto out_no_root; 616 617 sb->s_root = d_alloc_root(root_inode); 618 if (!sb->s_root) 619 goto out_no_root; 620 621 smb_new_dentry(sb->s_root); 622 623 return 0; 624 625out_no_root: 626 iput(root_inode); 627out_no_smbiod: 628 smb_unload_nls(server); 629out_bad_option: 630 kfree(mem); 631out_no_mem: 632 bdi_destroy(&server->bdi); 633out_bdi: 634 if (!server->mnt) 635 printk(KERN_ERR "smb_fill_super: allocation failure\n"); 636 sb->s_fs_info = NULL; 637 kfree(server); 638 goto out_fail; 639out_wrong_data: 640 printk(KERN_ERR "smbfs: mount_data version %d is not supported\n", ver); 641 goto out_fail; 642out_no_data: 643 printk(KERN_ERR "smb_fill_super: missing data argument\n"); 644out_fail: 645 return -EINVAL; 646out_no_server: 647 printk(KERN_ERR "smb_fill_super: cannot allocate struct smb_sb_info\n"); 648 return -ENOMEM; 649} 650 651static int 652smb_statfs(struct dentry *dentry, struct kstatfs *buf) 653{ 654 int result; 655 656 lock_kernel(); 657 658 result = smb_proc_dskattr(dentry, buf); 659 660 unlock_kernel(); 661 662 buf->f_type = SMB_SUPER_MAGIC; 663 buf->f_namelen = SMB_MAXPATHLEN; 664 return result; 665} 666 667int smb_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 668{ 669 int err = smb_revalidate_inode(dentry); 670 if (!err) 671 generic_fillattr(dentry->d_inode, stat); 672 return err; 673} 674 675int 676smb_notify_change(struct dentry *dentry, struct iattr *attr) 677{ 678 struct inode *inode = dentry->d_inode; 679 struct smb_sb_info *server = server_from_dentry(dentry); 680 unsigned int mask = (S_IFREG | S_IFDIR | S_IRWXUGO); 681 int error, changed, refresh = 0; 682 struct smb_fattr fattr; 683 684 lock_kernel(); 685 686 error = smb_revalidate_inode(dentry); 687 if (error) 688 goto out; 689 690 if ((error = inode_change_ok(inode, attr)) < 0) 691 goto out; 692 693 error = -EPERM; 694 if ((attr->ia_valid & ATTR_UID) && (attr->ia_uid != server->mnt->uid)) 695 goto out; 696 697 if ((attr->ia_valid & ATTR_GID) && (attr->ia_uid != server->mnt->gid)) 698 goto out; 699 700 if ((attr->ia_valid & ATTR_MODE) && (attr->ia_mode & ~mask)) 701 goto out; 702 703 if ((attr->ia_valid & ATTR_SIZE) != 0) { 704 VERBOSE("changing %s/%s, old size=%ld, new size=%ld\n", 705 DENTRY_PATH(dentry), 706 (long) inode->i_size, (long) attr->ia_size); 707 708 filemap_write_and_wait(inode->i_mapping); 709 710 error = smb_open(dentry, O_WRONLY); 711 if (error) 712 goto out; 713 error = server->ops->truncate(inode, attr->ia_size); 714 if (error) 715 goto out; 716 truncate_setsize(inode, attr->ia_size); 717 refresh = 1; 718 } 719 720 if (server->opt.capabilities & SMB_CAP_UNIX) { 721 /* For now we don't want to set the size with setattr_unix */ 722 attr->ia_valid &= ~ATTR_SIZE; 723 error = smb_proc_setattr_unix(dentry, attr, 0, 0); 724 if (!error) 725 refresh = 1; 726 727 goto out; 728 } 729 730 /* 731 * Initialize the fattr and check for changed fields. 732 * Note: CTIME under SMB is creation time rather than 733 * change time, so we don't attempt to change it. 734 */ 735 smb_get_inode_attr(inode, &fattr); 736 737 changed = 0; 738 if ((attr->ia_valid & ATTR_MTIME) != 0) { 739 fattr.f_mtime = attr->ia_mtime; 740 changed = 1; 741 } 742 if ((attr->ia_valid & ATTR_ATIME) != 0) { 743 fattr.f_atime = attr->ia_atime; 744 /* Earlier protocols don't have an access time */ 745 if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2) 746 changed = 1; 747 } 748 if (changed) { 749 error = smb_proc_settime(dentry, &fattr); 750 if (error) 751 goto out; 752 refresh = 1; 753 } 754 755 /* 756 * Check for mode changes ... we're extremely limited in 757 * what can be set for SMB servers: just the read-only bit. 758 */ 759 if ((attr->ia_valid & ATTR_MODE) != 0) { 760 VERBOSE("%s/%s mode change, old=%x, new=%x\n", 761 DENTRY_PATH(dentry), fattr.f_mode, attr->ia_mode); 762 changed = 0; 763 if (attr->ia_mode & S_IWUSR) { 764 if (fattr.attr & aRONLY) { 765 fattr.attr &= ~aRONLY; 766 changed = 1; 767 } 768 } else { 769 if (!(fattr.attr & aRONLY)) { 770 fattr.attr |= aRONLY; 771 changed = 1; 772 } 773 } 774 if (changed) { 775 error = smb_proc_setattr(dentry, &fattr); 776 if (error) 777 goto out; 778 refresh = 1; 779 } 780 } 781 error = 0; 782 783out: 784 if (refresh) 785 smb_refresh_inode(dentry); 786 unlock_kernel(); 787 return error; 788} 789 790static int smb_get_sb(struct file_system_type *fs_type, 791 int flags, const char *dev_name, void *data, struct vfsmount *mnt) 792{ 793 return get_sb_nodev(fs_type, flags, data, smb_fill_super, mnt); 794} 795 796static struct file_system_type smb_fs_type = { 797 .owner = THIS_MODULE, 798 .name = "smbfs", 799 .get_sb = smb_get_sb, 800 .kill_sb = kill_anon_super, 801 .fs_flags = FS_BINARY_MOUNTDATA, 802}; 803 804static int __init init_smb_fs(void) 805{ 806 int err; 807 DEBUG1("registering ...\n"); 808 809 err = init_inodecache(); 810 if (err) 811 goto out_inode; 812 err = smb_init_request_cache(); 813 if (err) 814 goto out_request; 815 err = register_filesystem(&smb_fs_type); 816 if (err) 817 goto out; 818 return 0; 819out: 820 smb_destroy_request_cache(); 821out_request: 822 destroy_inodecache(); 823out_inode: 824 return err; 825} 826 827static void __exit exit_smb_fs(void) 828{ 829 DEBUG1("unregistering ...\n"); 830 unregister_filesystem(&smb_fs_type); 831 smb_destroy_request_cache(); 832 destroy_inodecache(); 833} 834 835module_init(init_smb_fs) 836module_exit(exit_smb_fs) 837MODULE_LICENSE("GPL"); 838