lustre/smfs/file.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/smfs/inode.c
   5  *  Lustre filesystem abstraction routines
   6  *
   7  *  Copyright (C) 2004 Cluster File Systems, Inc.
   8  *
   9  *   This file is part of Lustre, http://www.lustre.org.
  10  *
  11  *   Lustre is free software; you can redistribute it and/or
  12  *   modify it under the terms of version 2 of the GNU General Public
  13  *   License as published by the Free Software Foundation.
  14  *
  15  *   Lustre is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *   GNU General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU General Public License
  21  *   along with Lustre; if not, write to the Free Software
  22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #define DEBUG_SUBSYSTEM S_SM
  26
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/string.h>
  30 #include <linux/slab.h>
  31 #include <linux/stat.h>
  32 #include <linux/unistd.h>
  33 #include <linux/pagemap.h>
  34 #include <linux/file.h>
  35 #include <linux/fs.h>
  36 #include <linux/obd_class.h>
  37 #include <linux/obd_support.h>
  38 #include <linux/lustre_lib.h>
  39 #include <linux/lustre_idl.h>
  40 #include <linux/lustre_fsfilt.h>
  41 #include <linux/lustre_smfs.h>
  42 #include <linux/lustre_snap.h>
  43
  44 #include "smfs_internal.h"
  45
  46 static ssize_t smfs_write(struct file *filp, const char *buf, size_t count,
  47                           loff_t *ppos)
  48 {
  49         struct inode *cache_inode = I2CI(filp->f_dentry->d_inode);
  50         struct smfs_file_info *sfi;
  51         loff_t *cache_ppos = NULL;
  52         int rc = 0;
  53         struct hook_write_msg msg = {
  54                 .dentry = filp->f_dentry,
  55                 .count = count,
  56                 .pos = *ppos
  57         };
  58
  59         ENTRY;
  60
  61         LASSERT(cache_inode);
  62         LASSERT(cache_inode->i_fop->write);
  63
  64         sfi = F2SMFI(filp);
  65         LASSERT(sfi->magic == SMFS_FILE_MAGIC);
  66
  67         if (filp->f_flags & O_APPEND)
  68                 msg.pos = filp->f_dentry->d_inode->i_size;
  69
  70         pre_smfs_file(filp, &msg.pos, &cache_ppos);
  71         SMFS_PRE_HOOK(filp->f_dentry->d_inode, HOOK_WRITE, &msg);
  72
  73         rc = cache_inode->i_fop->write(sfi->c_file, buf, count,
  74                                        cache_ppos);
  75
  76         SMFS_POST_HOOK(filp->f_dentry->d_inode, HOOK_WRITE, &msg, rc);
  77         post_smfs_file(filp);
  78         *ppos = *cache_ppos;
  79
  80         RETURN(rc);
  81 }
  82
  83 int smfs_ioctl(struct inode * inode, struct file * filp,
  84                unsigned int cmd, unsigned long arg)
  85 {
  86         struct  inode *cache_inode = I2CI(filp->f_dentry->d_inode);
  87         struct  smfs_file_info *sfi;
  88         ssize_t rc = 0;
  89
  90         ENTRY;
  91
  92         LASSERT(cache_inode);
  93         LASSERT(cache_inode->i_fop->ioctl);
  94
  95         sfi = F2SMFI(filp);
  96         if (sfi->magic != SMFS_FILE_MAGIC)
  97                 LBUG();
  98
  99         pre_smfs_inode(inode, cache_inode);
 100
 101         rc = cache_inode->i_fop->ioctl(cache_inode, sfi->c_file, cmd, arg);
 102
 103         post_smfs_inode(inode, cache_inode);
 104         duplicate_file(filp, sfi->c_file);
 105
 106         RETURN(rc);
 107 }
 108
 109 static ssize_t smfs_read(struct file *filp, char *buf,
 110                          size_t count, loff_t *ppos)
 111 {
 112         struct  inode *cache_inode = I2CI(filp->f_dentry->d_inode);
 113         struct  smfs_file_info *sfi;
 114         loff_t  *cache_ppos = NULL;
 115         ssize_t rc = 0;
 116
 117         ENTRY;
 118
 119         LASSERT(cache_inode);
 120         LASSERT(cache_inode->i_fop->read);
 121
 122         sfi = F2SMFI(filp);
 123         if (sfi->magic != SMFS_FILE_MAGIC)
 124                 LBUG();
 125
 126         pre_smfs_file(filp, ppos, &cache_ppos);
 127         rc = cache_inode->i_fop->read(sfi->c_file, buf, count, cache_ppos);
 128         post_smfs_file(filp);
 129
 130         RETURN(rc);
 131 }
 132
 133 static loff_t smfs_llseek(struct file *file, loff_t offset, int origin)
 134 {
 135         struct  inode *cache_inode = I2CI(file->f_dentry->d_inode);
 136         struct  smfs_file_info *sfi;
 137         ssize_t rc = 0;
 138
 139         ENTRY;
 140
 141         LASSERT(cache_inode);
 142         LASSERT(cache_inode->i_fop->llseek);
 143
 144         sfi = F2SMFI(file);
 145         if (sfi->magic != SMFS_FILE_MAGIC)
 146                 LBUG();
 147
 148         pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
 149
 150         rc = cache_inode->i_fop->llseek(sfi->c_file, offset, origin);
 151
 152         post_smfs_inode(file->f_dentry->d_inode, cache_inode);
 153         duplicate_file(file, sfi->c_file);
 154
 155         RETURN(rc);
 156 }
 157
 158 static int smfs_mmap(struct file *file, struct vm_area_struct *vma)
 159 {
 160         struct inode *inode = file->f_dentry->d_inode;
 161         struct smfs_file_info *sfi;
 162         struct inode *cache_inode = I2CI(inode);
 163         int rc = 0;
 164         ENTRY;
 165
 166         LASSERT(cache_inode);
 167
 168         sfi = F2SMFI(file);
 169         if (sfi->magic != SMFS_FILE_MAGIC)
 170                 LBUG();
 171
 172         if (cache_inode->i_mapping == &cache_inode->i_data)
 173                 inode->i_mapping = cache_inode->i_mapping;
 174
 175         pre_smfs_inode(inode, cache_inode);
 176
 177         rc = cache_inode->i_fop->mmap(sfi->c_file, vma);
 178
 179         post_smfs_inode(inode, cache_inode);
 180         duplicate_file(file, sfi->c_file);
 181
 182         RETURN(rc);
 183 }
 184
 185 static int smfs_init_cache_file(struct inode *inode, struct file *filp)
 186 {
 187         struct smfs_file_info *sfi = NULL;
 188         struct file *cache_filp = NULL;
 189         struct dentry *cache_dentry = NULL;
 190         int rc = 0;
 191         ENTRY;
 192
 193         OBD_ALLOC(sfi, sizeof(struct smfs_file_info));
 194         if (!sfi)
 195                 RETURN(-ENOMEM);
 196
 197         cache_filp = get_empty_filp();
 198         if (!cache_filp) {
 199                 rc = -ENOMEM;
 200                 goto err_exit;
 201         }
 202
 203         sfi->magic = SMFS_FILE_MAGIC;
 204
 205         cache_dentry = pre_smfs_dentry(NULL, I2CI(inode), filp->f_dentry);
 206         if (!cache_dentry) {
 207                 rc = -ENOMEM;
 208                 goto err_exit;
 209         }
 210
 211         cache_filp->f_vfsmnt = filp->f_vfsmnt;
 212         cache_filp->f_dentry = cache_dentry;
 213         duplicate_file(cache_filp, filp);
 214         sfi->c_file = cache_filp;
 215
 216         if (filp->private_data != NULL)
 217                 LBUG();
 218
 219         filp->private_data = sfi;
 220
 221         RETURN(0);
 222 err_exit:
 223         if (sfi)
 224                 OBD_FREE(sfi, sizeof(struct smfs_file_info));
 225         if (cache_filp)
 226                 put_filp(cache_filp);
 227         RETURN(rc);
 228 }
 229
 230 static int smfs_cleanup_cache_file(struct file *filp)
 231 {
 232         struct smfs_file_info *sfi = NULL;
 233
 234         ENTRY;
 235
 236         if (!filp)
 237                 RETURN(0);
 238
 239         sfi = F2SMFI(filp);
 240
 241         post_smfs_dentry(sfi->c_file->f_dentry);
 242
 243         put_filp(sfi->c_file);
 244
 245         OBD_FREE(sfi, sizeof(struct smfs_file_info));
 246
 247         filp->private_data = NULL;
 248
 249         RETURN(0);
 250 }
 251
 252 int smfs_open(struct inode *inode, struct file *filp)
 253 {
 254         struct inode *cache_inode = I2CI(inode);
 255         int rc = 0;
 256
 257         ENTRY;
 258
 259         LASSERT(cache_inode);
 260
 261         if ((rc = smfs_init_cache_file(inode, filp)))
 262                 RETURN(rc);
 263         //it possible that backstore fs has no open(),
 264         //but we need it to init cache filp
 265         if (cache_inode->i_fop->open) {
 266                 rc = cache_inode->i_fop->open(cache_inode, F2CF(filp));
 267                 duplicate_file(filp, F2CF(filp));
 268         }
 269
 270         RETURN(rc);
 271 }
 272
 273 int smfs_release(struct inode *inode, struct file *filp)
 274 {
 275         struct inode *cache_inode = I2CI(inode);
 276         struct file *cache_file = NULL;
 277         struct smfs_file_info *sfi = NULL;
 278         int rc = 0;
 279
 280         ENTRY;
 281
 282         LASSERT(cache_inode);
 283
 284         if (filp) {
 285                 sfi = F2SMFI(filp);
 286                 if (sfi->magic != SMFS_FILE_MAGIC)
 287                         LBUG();
 288                 cache_file = sfi->c_file;
 289         }
 290
 291         if (cache_inode->i_fop->release)
 292                 rc = cache_inode->i_fop->release(cache_inode, cache_file);
 293
 294         post_smfs_inode(inode, cache_inode);
 295
 296         smfs_cleanup_cache_file(filp);
 297
 298         RETURN(rc);
 299 }
 300
 301 int smfs_fsync(struct file *file, struct dentry *dentry, int datasync)
 302 {
 303         struct smfs_file_info *sfi = NULL;
 304         struct dentry *cache_dentry = NULL;
 305         struct file *cache_file = NULL;
 306         struct inode *cache_inode = I2CI(dentry->d_inode);
 307         int rc = 0;
 308
 309         ENTRY;
 310
 311         LASSERT(cache_inode);
 312         LASSERT(cache_inode->i_fop->fsync);
 313
 314         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 315         if (!cache_dentry)
 316                 RETURN(-ENOMEM);
 317
 318         if (file) {
 319                 sfi = F2SMFI(file);
 320                 if (sfi->magic != SMFS_FILE_MAGIC)
 321                         LBUG();
 322                 cache_file = sfi->c_file;
 323         }
 324
 325         pre_smfs_inode(dentry->d_inode, cache_inode);
 326
 327         rc = cache_inode->i_fop->fsync(cache_file,
 328                                        cache_dentry, datasync);
 329
 330         post_smfs_inode(dentry->d_inode, cache_inode);
 331         duplicate_file(file, cache_file);
 332         post_smfs_dentry(cache_dentry);
 333
 334         RETURN(rc);
 335 }
 336
 337 struct file_operations smfs_file_fops = {
 338         llseek:         smfs_llseek,
 339         read:           smfs_read,
 340         write:          smfs_write,
 341         ioctl:          smfs_ioctl,
 342         mmap:           smfs_mmap,
 343         open:           smfs_open,
 344         release:        smfs_release,
 345         fsync:          smfs_fsync,
 346 };
 347
 348 static void smfs_truncate(struct inode *inode)
 349 {
 350         struct inode *cache_inode = I2CI(inode);
 351
 352         if (!cache_inode || !cache_inode->i_op->truncate)
 353                 return;
 354
 355         pre_smfs_inode(inode, cache_inode);
 356
 357         cache_inode->i_op->truncate(cache_inode);
 358
 359         post_smfs_inode(inode, cache_inode);
 360
 361         return;
 362 }
 363
 364 int smfs_setattr(struct dentry *dentry, struct iattr *attr)
 365 {
 366         struct inode *cache_inode = I2CI(dentry->d_inode);
 367         struct dentry *cache_dentry;
 368         void  *handle = NULL;
 369         int rc = 0;
 370         struct hook_attr_msg msg = {
 371                 .dentry = dentry,
 372                 .attr = attr,
 373         };
 374
 375         ENTRY;
 376
 377         LASSERT(cache_inode);
 378         LASSERT(cache_inode->i_op->setattr);
 379
 380         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 381         if (!cache_dentry)
 382                 RETURN(-ENOMEM);
 383
 384         handle = smfs_trans_start(dentry->d_inode, FSFILT_OP_SETATTR, NULL);
 385         if (IS_ERR(handle) ) {
 386                 rc = -ENOSPC;
 387                 goto exit;
 388         }
 389
 390         pre_smfs_inode(dentry->d_inode, cache_inode);
 391
 392         SMFS_PRE_HOOK(dentry->d_inode, HOOK_SETATTR, &msg);
 393
 394         rc = cache_inode->i_op->setattr(cache_dentry, attr);
 395
 396         SMFS_POST_HOOK(dentry->d_inode, HOOK_SETATTR, &msg, rc);
 397
 398         post_smfs_inode(dentry->d_inode, cache_inode);
 399         smfs_trans_commit(dentry->d_inode, handle, 0);
 400 exit:
 401         post_smfs_dentry(cache_dentry);
 402         RETURN(rc);
 403 }
 404
 405 int smfs_setxattr(struct dentry *dentry, const char *name,
 406                   const void *value, size_t size, int flags)
 407 {
 408         struct inode *cache_inode = I2CI(dentry->d_inode);
 409         struct dentry *cache_dentry = NULL;
 410         struct hook_xattr_msg msg = {
 411                 .name = (char*)name,
 412         };
 413         int rc = 0;
 414
 415         ENTRY;
 416
 417         LASSERT(cache_inode);
 418         LASSERT(cache_inode->i_op->setxattr);
 419
 420         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 421         if (!cache_dentry)
 422                 RETURN(-ENOMEM);
 423
 424         pre_smfs_inode(dentry->d_inode, cache_inode);
 425         SMFS_PRE_HOOK(dentry->d_inode, HOOK_SETXATTR, &msg);
 426
 427         rc = cache_inode->i_op->setxattr(cache_dentry, name, value,
 428                                          size, flags);
 429
 430         SMFS_POST_HOOK(dentry->d_inode, HOOK_SETXATTR, &msg, rc);
 431
 432         post_smfs_inode(dentry->d_inode, cache_inode);
 433         post_smfs_dentry(cache_dentry);
 434
 435         RETURN(rc);
 436 }
 437
 438 int smfs_getxattr(struct dentry *dentry, const char *name,
 439                   void *buffer, size_t size)
 440 {
 441         struct inode *cache_inode = I2CI(dentry->d_inode);
 442         struct dentry *cache_dentry;
 443         struct hook_xattr_msg msg = {
 444                 .name = (char*)name,
 445         };
 446         int rc = 0;
 447
 448         ENTRY;
 449
 450         LASSERT(cache_inode);
 451         LASSERT(cache_inode->i_op->getxattr);
 452
 453         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 454         if (!cache_dentry)
 455                 RETURN(-ENOMEM);
 456
 457         pre_smfs_inode(dentry->d_inode, cache_inode);
 458         SMFS_PRE_HOOK(dentry->d_inode, HOOK_GETXATTR, &msg);
 459         rc = cache_inode->i_op->getxattr(cache_dentry, name, buffer,
 460                                          size);
 461         SMFS_POST_HOOK(dentry->d_inode, HOOK_GETXATTR, &msg, rc);
 462         post_smfs_inode(dentry->d_inode, cache_inode);
 463         post_smfs_dentry(cache_dentry);
 464
 465         RETURN(rc);
 466 }
 467
 468 ssize_t smfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 469 {
 470         struct inode *cache_inode = I2CI(dentry->d_inode);
 471         struct dentry *cache_dentry;
 472         int rc = 0;
 473         struct hook_xattr_msg msg = {
 474                 .name = NULL,
 475         };
 476
 477         ENTRY;
 478
 479         LASSERT(cache_inode);
 480         LASSERT(cache_inode->i_op->listxattr);
 481
 482         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 483         if (!cache_dentry)
 484                 RETURN(-ENOMEM);
 485
 486         pre_smfs_inode(dentry->d_inode, cache_inode);
 487         SMFS_PRE_HOOK(dentry->d_inode, HOOK_LISTXATTR, &msg);
 488
 489         rc = cache_inode->i_op->listxattr(cache_dentry, buffer, size);
 490
 491         SMFS_POST_HOOK(dentry->d_inode, HOOK_LISTXATTR, &msg, rc);
 492         post_smfs_inode(dentry->d_inode, cache_inode);
 493         post_smfs_dentry(cache_dentry);
 494
 495         RETURN(rc);
 496 }
 497
 498 int smfs_removexattr(struct dentry *dentry, const char *name)
 499 {
 500         struct inode *cache_inode = I2CI(dentry->d_inode);
 501         struct dentry *cache_dentry;
 502         int rc = 0;
 503         struct hook_xattr_msg msg = {
 504                 .name = (char*)name,
 505         };
 506         ENTRY;
 507
 508         LASSERT(cache_inode);
 509         LASSERT(cache_inode->i_op->removexattr);
 510
 511         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 512         if (!cache_dentry)
 513                 RETURN(-ENOMEM);
 514
 515         pre_smfs_inode(dentry->d_inode, cache_inode);
 516         SMFS_PRE_HOOK(dentry->d_inode, HOOK_REMOVEXATTR, &msg);
 517
 518         rc = cache_inode->i_op->removexattr(cache_dentry, name);
 519
 520         SMFS_POST_HOOK(dentry->d_inode, HOOK_REMOVEXATTR, &msg, rc);
 521         post_smfs_inode(dentry->d_inode, cache_inode);
 522         post_smfs_dentry(cache_dentry);
 523
 524         RETURN(rc);
 525 }
 526
 527 int smfs_permission(struct inode *inode, int mask, struct nameidata *nd)
 528 {
 529         struct inode *cache_inode = I2CI(inode);
 530         int rc = 0;
 531
 532         ENTRY;
 533
 534         LASSERT(cache_inode);
 535         LASSERT(cache_inode->i_op->permission);
 536
 537         pre_smfs_inode(inode, cache_inode);
 538
 539         rc = cache_inode->i_op->permission(cache_inode, mask, nd);
 540
 541         post_smfs_inode(inode, cache_inode);
 542
 543         RETURN(rc);
 544 }
 545
 546 struct inode_operations smfs_file_iops = {
 547         .truncate       = smfs_truncate,          /* BKL held */
 548         .setattr        = smfs_setattr,           /* BKL held */
 549         .setxattr       = smfs_setxattr,
 550         .getxattr       = smfs_getxattr,
 551         .listxattr      = smfs_listxattr,
 552         .removexattr    = smfs_removexattr,
 553         .permission     = smfs_permission,
 554 };
 555
 556 struct inode_operations smfs_special_iops = {
 557         .setattr        = smfs_setattr,           /* BKL held */
 558         .setxattr       = smfs_setxattr,
 559         .getxattr       = smfs_getxattr,
 560         .listxattr      = smfs_listxattr,
 561         .removexattr    = smfs_removexattr,
 562         .permission     = smfs_permission,
 563 };
 564