fs/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  */
   8
   9 #include <linux/module.h>
  10 #include <linux/sched.h>
  11 #include <linux/kernel.h>
  12 #include <linux/mm.h>
  13 #include <linux/string.h>
  14 #include <linux/stat.h>
  15 #include <linux/errno.h>
  16 #include <linux/locks.h>
  17 #include <linux/malloc.h>
  18 #include <linux/init.h>
  19 #include <linux/file.h>
  20 #include <linux/dcache.h>
  21
  22 #include <linux/smb_fs.h>
  23 #include <linux/smbno.h>
  24 #include <linux/smb_mount.h>
  25
  26 #include <asm/system.h>
  27 #include <asm/uaccess.h>
  28
  29 #define SMBFS_PARANOIA 1
  30 /* #define SMBFS_DEBUG_VERBOSE 1 */
  31
  32 static void smb_put_inode(struct inode *);
  33 static void smb_delete_inode(struct inode *);
  34 static void smb_put_super(struct super_block *);
  35 static int  smb_statfs(struct super_block *, struct statfs *);
  36 static void smb_set_inode_attr(struct inode *, struct smb_fattr *);
  37
  38 static struct super_operations smb_sops =
  39 {
  40         put_inode:      smb_put_inode,
  41         delete_inode:   smb_delete_inode,
  42         put_super:      smb_put_super,
  43         statfs:         smb_statfs,
  44 };
  45
  46 /* FIXME: Look at all inodes whether so that we do not get duplicate
  47  * inode numbers. */
  48
  49 unsigned long
  50 smb_invent_inos(unsigned long n)
  51 {
  52         static unsigned long ino = 2;
  53
  54         if (ino + 2*n < ino)
  55         {
  56                 /* wrap around */
  57                 ino = 2;
  58         }
  59         ino += n;
  60         return ino;
  61 }
  62
  63 /* We are always generating a new inode here */
  64 struct inode *
  65 smb_iget(struct super_block *sb, struct smb_fattr *fattr)
  66 {
  67         struct inode *result;
  68
  69         pr_debug("smb_iget: %p\n", fattr);
  70
  71         result = get_empty_inode();
  72         if (!result)
  73                 return result;
  74         result->i_sb = sb;
  75         result->i_dev = sb->s_dev;
  76         result->i_ino = fattr->f_ino;
  77         memset(&(result->u.smbfs_i), 0, sizeof(result->u.smbfs_i));
  78         smb_set_inode_attr(result, fattr);
  79         if (S_ISREG(result->i_mode)) {
  80                 result->i_op = &smb_file_inode_operations;
  81                 result->i_fop = &smb_file_operations;
  82                 result->i_data.a_ops = &smb_file_aops;
  83         } else if (S_ISDIR(result->i_mode)) {
  84                 result->i_op = &smb_dir_inode_operations;
  85                 result->i_fop = &smb_dir_operations;
  86         }
  87         insert_inode_hash(result);
  88         return result;
  89 }
  90
  91 /*
  92  * Copy the inode data to a smb_fattr structure.
  93  */
  94 void
  95 smb_get_inode_attr(struct inode *inode, struct smb_fattr *fattr)
  96 {
  97         memset(fattr, 0, sizeof(struct smb_fattr));
  98         fattr->f_mode   = inode->i_mode;
  99         fattr->f_nlink  = inode->i_nlink;
 100         fattr->f_ino    = inode->i_ino;
 101         fattr->f_uid    = inode->i_uid;
 102         fattr->f_gid    = inode->i_gid;
 103         fattr->f_rdev   = inode->i_rdev;
 104         fattr->f_size   = inode->i_size;
 105         fattr->f_mtime  = inode->i_mtime;
 106         fattr->f_ctime  = inode->i_ctime;
 107         fattr->f_atime  = inode->i_atime;
 108         fattr->f_blksize= inode->i_blksize;
 109         fattr->f_blocks = inode->i_blocks;
 110
 111         fattr->attr     = inode->u.smbfs_i.attr;
 112         /*
 113          * Keep the attributes in sync with the inode permissions.
 114          */
 115         if (fattr->f_mode & S_IWUSR)
 116                 fattr->attr &= ~aRONLY;
 117         else
 118                 fattr->attr |= aRONLY;
 119 }
 120
 121 static void
 122 smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr)
 123 {
 124         inode->i_mode   = fattr->f_mode;
 125         inode->i_nlink  = fattr->f_nlink;
 126         inode->i_uid    = fattr->f_uid;
 127         inode->i_gid    = fattr->f_gid;
 128         inode->i_rdev   = fattr->f_rdev;
 129         inode->i_ctime  = fattr->f_ctime;
 130         inode->i_blksize= fattr->f_blksize;
 131         inode->i_blocks = fattr->f_blocks;
 132         /*
 133          * Don't change the size and mtime/atime fields
 134          * if we're writing to the file.
 135          */
 136         if (!(inode->u.smbfs_i.cache_valid & SMB_F_LOCALWRITE))
 137         {
 138                 inode->i_size  = fattr->f_size;
 139                 inode->i_mtime = fattr->f_mtime;
 140                 inode->i_atime = fattr->f_atime;
 141         }
 142
 143         inode->u.smbfs_i.attr = fattr->attr;
 144         /*
 145          * Update the "last time refreshed" field for revalidation.
 146          */
 147         inode->u.smbfs_i.oldmtime = jiffies;
 148 }
 149
 150 /*
 151  * This is called if the connection has gone bad ...
 152  * try to kill off all the current inodes.
 153  */
 154 void
 155 smb_invalidate_inodes(struct smb_sb_info *server)
 156 {
 157 #ifdef SMBFS_DEBUG_VERBOSE
 158 printk("smb_invalidate_inodes\n");
 159 #endif
 160         shrink_dcache_sb(SB_of(server));
 161         invalidate_inodes(SB_of(server));
 162 }
 163
 164 /*
 165  * This is called to update the inode attributes after
 166  * we've made changes to a file or directory.
 167  */
 168 static int
 169 smb_refresh_inode(struct dentry *dentry)
 170 {
 171         struct inode *inode = dentry->d_inode;
 172         int error;
 173         struct smb_fattr fattr;
 174
 175         error = smb_proc_getattr(dentry, &fattr);
 176         if (!error)
 177         {
 178                 smb_renew_times(dentry);
 179                 /*
 180                  * Check whether the type part of the mode changed,
 181                  * and don't update the attributes if it did.
 182                  */
 183                 if ((inode->i_mode & S_IFMT) == (fattr.f_mode & S_IFMT))
 184                         smb_set_inode_attr(inode, &fattr);
 185                 else
 186                 {
 187                         /*
 188                          * Big trouble! The inode has become a new object,
 189                          * so any operations attempted on it are invalid.
 190                          *
 191                          * To limit damage, mark the inode as bad so that
 192                          * subsequent lookup validations will fail.
 193                          */
 194 #ifdef SMBFS_PARANOIA
 195 printk("smb_refresh_inode: %s/%s changed mode, %07o to %07o\n",
 196 dentry->d_parent->d_name.name, dentry->d_name.name,
 197 inode->i_mode, fattr.f_mode);
 198 #endif
 199                         fattr.f_mode = inode->i_mode; /* save mode */
 200                         make_bad_inode(inode);
 201                         inode->i_mode = fattr.f_mode; /* restore mode */
 202                         /*
 203                          * No need to worry about unhashing the dentry: the
 204                          * lookup validation will see that the inode is bad.
 205                          * But we do want to invalidate the caches ...
 206                          */
 207                         if (!S_ISDIR(inode->i_mode))
 208                                 invalidate_inode_pages(inode);
 209                         else
 210                                 smb_invalid_dir_cache(inode);
 211                         error = -EIO;
 212                 }
 213         }
 214         return error;
 215 }
 216
 217 /*
 218  * This is called when we want to check whether the inode
 219  * has changed on the server.  If it has changed, we must
 220  * invalidate our local caches.
 221  */
 222 int
 223 smb_revalidate_inode(struct dentry *dentry)
 224 {
 225         struct inode *inode = dentry->d_inode;
 226         time_t last_time;
 227         int error = 0;
 228
 229         pr_debug("smb_revalidate_inode\n");
 230         /*
 231          * If this is a file opened with write permissions,
 232          * the inode will be up-to-date.
 233          */
 234         if (S_ISREG(inode->i_mode) && smb_is_open(inode))
 235         {
 236                 if (inode->u.smbfs_i.access != SMB_O_RDONLY)
 237                         goto out;
 238         }
 239
 240         /*
 241          * Check whether we've recently refreshed the inode.
 242          */
 243         if (time_before(jiffies, inode->u.smbfs_i.oldmtime + HZ/10))
 244         {
 245 #ifdef SMBFS_DEBUG_VERBOSE
 246 printk("smb_revalidate_inode: up-to-date, jiffies=%lu, oldtime=%lu\n",
 247 jiffies, inode->u.smbfs_i.oldmtime);
 248 #endif
 249                 goto out;
 250         }
 251
 252         /*
 253          * Save the last modified time, then refresh the inode.
 254          * (Note: a size change should have a different mtime.)
 255          */
 256         last_time = inode->i_mtime;
 257         error = smb_refresh_inode(dentry);
 258         if (error || inode->i_mtime != last_time)
 259         {
 260 #ifdef SMBFS_DEBUG_VERBOSE
 261 printk("smb_revalidate: %s/%s changed, old=%ld, new=%ld\n",
 262 dentry->d_parent->d_name.name, dentry->d_name.name,
 263 (long) last_time, (long) inode->i_mtime);
 264 #endif
 265                 if (!S_ISDIR(inode->i_mode))
 266                         invalidate_inode_pages(inode);
 267                 else
 268                         smb_invalid_dir_cache(inode);
 269         }
 270 out:
 271         return error;
 272 }
 273
 274 /*
 275  * This routine is called for every iput(). We clear i_nlink
 276  * on the last use to force a call to delete_inode.
 277  */
 278 static void
 279 smb_put_inode(struct inode *ino)
 280 {
 281         pr_debug("smb_put_inode: count = %d\n", ino->i_count);
 282         if (ino->i_count == 1)
 283                 ino->i_nlink = 0;
 284 }
 285
 286 /*
 287  * This routine is called when i_nlink == 0 and i_count goes to 0.
 288  * All blocking cleanup operations need to go here to avoid races.
 289  */
 290 static void
 291 smb_delete_inode(struct inode *ino)
 292 {
 293         pr_debug("smb_delete_inode\n");
 294         if (smb_close(ino))
 295                 printk("smb_delete_inode: could not close inode %ld\n",
 296                         ino->i_ino);
 297         clear_inode(ino);
 298 }
 299
 300 static void
 301 smb_put_super(struct super_block *sb)
 302 {
 303         struct smb_sb_info *server = &(sb->u.smbfs_sb);
 304
 305         if (server->sock_file) {
 306                 smb_proc_disconnect(server);
 307                 smb_dont_catch_keepalive(server);
 308                 fput(server->sock_file);
 309         }
 310
 311         if (server->conn_pid)
 312                kill_proc(server->conn_pid, SIGTERM, 1);
 313
 314         kfree(server->mnt);
 315         kfree(sb->u.smbfs_sb.temp_buf);
 316         if (server->packet)
 317                 smb_vfree(server->packet);
 318 }
 319
 320 struct super_block *
 321 smb_read_super(struct super_block *sb, void *raw_data, int silent)
 322 {
 323         struct smb_mount_data *mnt;
 324         struct inode *root_inode;
 325         struct smb_fattr root;
 326
 327         if (!raw_data)
 328                 goto out_no_data;
 329         if (((struct smb_mount_data *) raw_data)->version != SMB_MOUNT_VERSION)
 330                 goto out_wrong_data;
 331
 332         sb->s_blocksize = 1024; /* Eh...  Is this correct? */
 333         sb->s_blocksize_bits = 10;
 334         sb->s_magic = SMB_SUPER_MAGIC;
 335         sb->s_flags = 0;
 336         sb->s_op = &smb_sops;
 337
 338         sb->u.smbfs_sb.sock_file = NULL;
 339         init_MUTEX(&sb->u.smbfs_sb.sem);
 340         init_waitqueue_head(&sb->u.smbfs_sb.wait);
 341         sb->u.smbfs_sb.conn_pid = 0;
 342         sb->u.smbfs_sb.state = CONN_INVALID; /* no connection yet */
 343         sb->u.smbfs_sb.generation = 0;
 344         sb->u.smbfs_sb.packet_size = smb_round_length(SMB_INITIAL_PACKET_SIZE);
 345         sb->u.smbfs_sb.packet = smb_vmalloc(sb->u.smbfs_sb.packet_size);
 346         if (!sb->u.smbfs_sb.packet)
 347                 goto out_no_mem;
 348
 349         /* Allocate the global temp buffer */
 350         sb->u.smbfs_sb.temp_buf = kmalloc(SMB_MAXPATHLEN + 20, GFP_KERNEL);
 351         if (!sb->u.smbfs_sb.temp_buf)
 352                 goto out_no_temp;
 353
 354         /* Allocate the mount data structure */
 355         mnt = kmalloc(sizeof(struct smb_mount_data), GFP_KERNEL);
 356         if (!mnt)
 357                 goto out_no_mount;
 358         *mnt = *((struct smb_mount_data *) raw_data);
 359         /* ** temp ** pass config flags in file mode */
 360         mnt->version = (mnt->file_mode >> 9);
 361         mnt->file_mode &= (S_IRWXU | S_IRWXG | S_IRWXO);
 362         mnt->file_mode |= S_IFREG;
 363         mnt->dir_mode  &= (S_IRWXU | S_IRWXG | S_IRWXO);
 364         mnt->dir_mode  |= S_IFDIR;
 365         sb->u.smbfs_sb.mnt = mnt;
 366         /*
 367          * Display the enabled options
 368          */
 369         if (mnt->version & SMB_FIX_OLDATTR)
 370                 printk("SMBFS: Using core getattr (Win 95 speedup)\n");
 371         else if (mnt->version & SMB_FIX_DIRATTR)
 372                 printk("SMBFS: Using dir ff getattr\n");
 373
 374         /*
 375          * Keep the super block locked while we get the root inode.
 376          */
 377         smb_init_root_dirent(&(sb->u.smbfs_sb), &root);
 378         root_inode = smb_iget(sb, &root);
 379         if (!root_inode)
 380                 goto out_no_root;
 381
 382         sb->s_root = d_alloc_root(root_inode);
 383         if (!sb->s_root)
 384                 goto out_no_root;
 385
 386         return sb;
 387
 388 out_no_root:
 389         iput(root_inode);
 390         kfree(sb->u.smbfs_sb.mnt);
 391 out_no_mount:
 392         kfree(sb->u.smbfs_sb.temp_buf);
 393 out_no_temp:
 394         smb_vfree(sb->u.smbfs_sb.packet);
 395 out_no_mem:
 396         printk(KERN_ERR "smb_read_super: allocation failure\n");
 397         goto out_fail;
 398 out_wrong_data:
 399         printk(KERN_ERR "SMBFS: need mount version %d\n", SMB_MOUNT_VERSION);
 400         goto out_fail;
 401 out_no_data:
 402         printk("smb_read_super: missing data argument\n");
 403 out_fail:
 404         return NULL;
 405 }
 406
 407 static int
 408 smb_statfs(struct super_block *sb, struct statfs *buf)
 409 {
 410         smb_proc_dskattr(sb, buf);
 411
 412         buf->f_type = SMB_SUPER_MAGIC;
 413         buf->f_namelen = SMB_MAXPATHLEN;
 414         return 0;
 415 }
 416
 417 int
 418 smb_notify_change(struct dentry *dentry, struct iattr *attr)
 419 {
 420         struct inode *inode = dentry->d_inode;
 421         struct smb_sb_info *server = server_from_dentry(dentry);
 422         unsigned int mask = (S_IFREG | S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);
 423         int error, changed, refresh = 0;
 424         struct smb_fattr fattr;
 425
 426         error = smb_revalidate_inode(dentry);
 427         if (error)
 428                 goto out;
 429
 430         if ((error = inode_change_ok(inode, attr)) < 0)
 431                 goto out;
 432
 433         error = -EPERM;
 434         if ((attr->ia_valid & ATTR_UID) && (attr->ia_uid != server->mnt->uid))
 435                 goto out;
 436
 437         if ((attr->ia_valid & ATTR_GID) && (attr->ia_uid != server->mnt->gid))
 438                 goto out;
 439
 440         if ((attr->ia_valid & ATTR_MODE) && (attr->ia_mode & ~mask))
 441                 goto out;
 442
 443         if ((attr->ia_valid & ATTR_SIZE) != 0)
 444         {
 445 #ifdef SMBFS_DEBUG_VERBOSE
 446 printk("smb_notify_change: changing %s/%s, old size=%ld, new size=%ld\n",
 447 dentry->d_parent->d_name.name, dentry->d_name.name,
 448 (long) inode->i_size, (long) attr->ia_size);
 449 #endif
 450                 error = smb_open(dentry, O_WRONLY);
 451                 if (error)
 452                         goto out;
 453                 error = smb_proc_trunc(server, inode->u.smbfs_i.fileid,
 454                                          attr->ia_size);
 455                 if (error)
 456                         goto out;
 457                 vmtruncate(inode, attr->ia_size);
 458                 refresh = 1;
 459         }
 460
 461         /*
 462          * Initialize the fattr and check for changed fields.
 463          * Note: CTIME under SMB is creation time rather than
 464          * change time, so we don't attempt to change it.
 465          */
 466         smb_get_inode_attr(inode, &fattr);
 467
 468         changed = 0;
 469         if ((attr->ia_valid & ATTR_MTIME) != 0)
 470         {
 471                 fattr.f_mtime = attr->ia_mtime;
 472                 changed = 1;
 473         }
 474         if ((attr->ia_valid & ATTR_ATIME) != 0)
 475         {
 476                 fattr.f_atime = attr->ia_atime;
 477                 /* Earlier protocols don't have an access time */
 478                 if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2)
 479                         changed = 1;
 480         }
 481         if (changed)
 482         {
 483                 error = smb_proc_settime(dentry, &fattr);
 484                 if (error)
 485                         goto out;
 486                 refresh = 1;
 487         }
 488
 489         /*
 490          * Check for mode changes ... we're extremely limited in
 491          * what can be set for SMB servers: just the read-only bit.
 492          */
 493         if ((attr->ia_valid & ATTR_MODE) != 0)
 494         {
 495 #ifdef SMBFS_DEBUG_VERBOSE
 496 printk("smb_notify_change: %s/%s mode change, old=%x, new=%lx\n",
 497 dentry->d_parent->d_name.name, dentry->d_name.name, fattr.f_mode,attr->ia_mode);
 498 #endif
 499                 changed = 0;
 500                 if (attr->ia_mode & S_IWUSR)
 501                 {
 502                         if (fattr.attr & aRONLY)
 503                         {
 504                                 fattr.attr &= ~aRONLY;
 505                                 changed = 1;
 506                         }
 507                 } else
 508                 {
 509                         if (!(fattr.attr & aRONLY))
 510                         {
 511                                 fattr.attr |= aRONLY;
 512                                 changed = 1;
 513                         }
 514                 }
 515                 if (changed)
 516                 {
 517                         error = smb_proc_setattr(dentry, &fattr);
 518                         if (error)
 519                                 goto out;
 520                         refresh = 1;
 521                 }
 522         }
 523         error = 0;
 524
 525 out:
 526         if (refresh)
 527                 smb_refresh_inode(dentry);
 528         return error;
 529 }
 530
 531 #ifdef DEBUG_SMB_MALLOC
 532 int smb_malloced;
 533 int smb_current_kmalloced;
 534 int smb_current_vmalloced;
 535 #endif
 536
 537 static DECLARE_FSTYPE( smb_fs_type, "smbfs", smb_read_super, 0);
 538
 539 static int __init init_smb_fs(void)
 540 {
 541         pr_debug("smbfs: init_module called\n");
 542
 543 #ifdef DEBUG_SMB_MALLOC
 544         smb_malloced = 0;
 545         smb_current_kmalloced = 0;
 546         smb_current_vmalloced = 0;
 547 #endif
 548
 549         return init_smb_fs();
 550 }
 551
 552 static void __exit exit_smb_fs(void)
 553 {
 554         pr_debug("smbfs: cleanup_module called\n");
 555         unregister_filesystem(&smb_fs_type);
 556 #ifdef DEBUG_SMB_MALLOC
 557         printk(KERN_DEBUG "smb_malloced: %d\n", smb_malloced);
 558         printk(KERN_DEBUG "smb_current_kmalloced: %d\n",smb_current_kmalloced);
 559         printk(KERN_DEBUG "smb_current_vmalloced: %d\n",smb_current_vmalloced);
 560 #endif
 561 }
 562
 563 EXPORT_NO_SYMBOLS;
 564
 565 module_init(init_smb_fs)
 566 module_exit(exit_smb_fs)