drivers/staging/smbfs/inode.c

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