lustre/llite/rw.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Lustre Lite I/O Page Cache
   5  *
   6  * Copyright (C) 2002 Cluster File Systems, Inc.
   7  */
   8
   9 #include <linux/config.h>
  10 #include <linux/kernel.h>
  11 #include <linux/mm.h>
  12 #include <linux/string.h>
  13 #include <linux/stat.h>
  14 #include <linux/iobuf.h>
  15 #include <linux/errno.h>
  16 #include <linux/locks.h>
  17 #include <linux/unistd.h>
  18 #include <linux/version.h>
  19 #include <asm/system.h>
  20 #include <asm/uaccess.h>
  21
  22 #include <linux/fs.h>
  23 #include <linux/stat.h>
  24 #include <asm/uaccess.h>
  25 #include <asm/segment.h>
  26 #include <linux/mm.h>
  27 #include <linux/pagemap.h>
  28 #include <linux/smp_lock.h>
  29
  30 #define DEBUG_SUBSYSTEM S_LLITE
  31
  32 #include <linux/lustre_mds.h>
  33 #include <linux/lustre_lite.h>
  34
  35 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10))
  36 /*
  37  * Add a page to the dirty page list.
  38  */
  39 void __set_page_dirty(struct page *page)
  40 {
  41         struct address_space *mapping;
  42         spinlock_t *pg_lock;
  43
  44         pg_lock = PAGECACHE_LOCK(page);
  45         spin_lock(pg_lock);
  46
  47         mapping = page->mapping;
  48         spin_lock(&mapping->page_lock);
  49
  50         list_del(&page->list);
  51         list_add(&page->list, &mapping->dirty_pages);
  52
  53         spin_unlock(&mapping->page_lock);
  54         spin_unlock(pg_lock);
  55
  56         if (mapping->host)
  57                 mark_inode_dirty_pages(mapping->host);
  58 }
  59 #else
  60 /*
  61  * Add a page to the dirty page list.
  62  */
  63 void set_page_dirty(struct page *page)
  64 {
  65         if (!test_and_set_bit(PG_dirty, &page->flags)) {
  66                 struct address_space *mapping = page->mapping;
  67
  68                 if (mapping) {
  69                         spin_lock(&pagecache_lock);
  70                         list_del(&page->list);
  71                         list_add(&page->list, &mapping->dirty_pages);
  72                         spin_unlock(&pagecache_lock);
  73
  74                         if (mapping->host)
  75                                 mark_inode_dirty_pages(mapping->host);
  76                 }
  77         }
  78 }
  79 #endif
  80
  81 inline struct obdo * ll_oa_from_inode(struct inode *inode, unsigned long valid)
  82 {
  83         struct ll_inode_info *oinfo = ll_i2info(inode);
  84         struct obdo *oa = obdo_alloc();
  85         if ( !oa ) {
  86                 CERROR("no memory to allocate obdo!\n");
  87                 return NULL;
  88         }
  89         oa->o_valid = valid;
  90
  91         if ( oa->o_valid & OBD_MD_FLID )
  92                 oa->o_id = oinfo->lli_objid;
  93         if ( oa->o_valid & OBD_MD_FLATIME )
  94                 oa->o_atime = inode->i_atime;
  95         if ( oa->o_valid & OBD_MD_FLMTIME )
  96                 oa->o_mtime = inode->i_mtime;
  97         if ( oa->o_valid & OBD_MD_FLCTIME )
  98                 oa->o_ctime = inode->i_ctime;
  99         if ( oa->o_valid & OBD_MD_FLSIZE )
 100                 oa->o_size = inode->i_size;
 101         if ( oa->o_valid & OBD_MD_FLBLOCKS )   /* allocation of space */
 102                 oa->o_blocks = inode->i_blocks;
 103         if ( oa->o_valid & OBD_MD_FLBLKSZ )
 104                 oa->o_blksize = inode->i_blksize;
 105         if ( oa->o_valid & OBD_MD_FLMODE )
 106                 oa->o_mode = inode->i_mode;
 107         if ( oa->o_valid & OBD_MD_FLUID )
 108                 oa->o_uid = inode->i_uid;
 109         if ( oa->o_valid & OBD_MD_FLGID )
 110                 oa->o_gid = inode->i_gid;
 111         if ( oa->o_valid & OBD_MD_FLFLAGS )
 112                 oa->o_flags = inode->i_flags;
 113         if ( oa->o_valid & OBD_MD_FLNLINK )
 114                 oa->o_nlink = inode->i_nlink;
 115         if ( oa->o_valid & OBD_MD_FLGENER )
 116                 oa->o_generation = inode->i_generation;
 117
 118         CDEBUG(D_INFO, "src inode %ld, dst obdo %ld valid 0x%08x\n",
 119                inode->i_ino, (long)oa->o_id, oa->o_valid);
 120 #if 0
 121         /* this will transfer metadata for the logical object to
 122            the oa: that metadata could contain the constituent objects
 123         */
 124         if (ll_has_inline(inode)) {
 125                 CDEBUG(D_INODE, "copying inline data from inode to obdo\n");
 126                 memcpy(oa->o_inline, oinfo->lli_inline, OBD_INLINESZ);
 127                 oa->o_obdflags |= OBD_FL_INLINEDATA;
 128                 oa->o_valid |= OBD_MD_FLINLINE;
 129         }
 130 #endif
 131         return oa;
 132 } /* ll_oa_from_inode */
 133
 134
 135
 136 /*
 137  * Remove page from dirty list
 138  */
 139 void __set_page_clean(struct page *page)
 140 {
 141         struct address_space *mapping = page->mapping;
 142         struct inode *inode;
 143
 144         if (!mapping)
 145                 return;
 146
 147         list_del(&page->list);
 148         list_add(&page->list, &mapping->clean_pages);
 149
 150         inode = mapping->host;
 151         if (list_empty(&mapping->dirty_pages)) {
 152                 CDEBUG(D_INODE, "inode clean\n");
 153                 inode->i_state &= ~I_DIRTY_PAGES;
 154         }
 155         EXIT;
 156 }
 157
 158 /* SYNCHRONOUS I/O to object storage for an inode */
 159 static int ll_brw(int rw, struct inode *inode, struct page *page, int create)
 160 {
 161         obd_count        num_obdo = 1;
 162         obd_count        bufs_per_obdo = 1;
 163         struct obdo     *oa;
 164         obd_size         count = PAGE_SIZE;
 165         obd_off          offset = ((obd_off)page->index) << PAGE_SHIFT;
 166         obd_flag         flags = create ? OBD_BRW_CREATE : 0;
 167         int              err;
 168         ENTRY;
 169
 170         oa = ll_oa_from_inode(inode, OBD_MD_FLNOTOBD);
 171         if (!oa)
 172                 RETURN(-ENOMEM);
 173
 174         err = obd_brw(rw, ll_i2obdconn(inode), num_obdo, &oa, &bufs_per_obdo,
 175                       &page, &count, &offset, &flags);
 176
 177         obdo_free(oa);
 178         RETURN(err);
 179 } /* ll_brw */
 180
 181 extern void set_page_clean(struct page *);
 182
 183
 184
 185 /* returns the page unlocked, but with a reference */
 186 static int ll_readpage(struct file *file, struct page *page)
 187 {
 188         struct inode *inode = page->mapping->host;
 189         int rc = 0;
 190         ENTRY;
 191
 192         if (!PageLocked(page))
 193                 LBUG();
 194
 195         if (((inode->i_size + PAGE_CACHE_SIZE -1)>>PAGE_SHIFT) <= page->index) {
 196                 memset(kmap(page), 0, PAGE_CACHE_SIZE);
 197                 kunmap(page);
 198                 GOTO(readpage_out, rc);
 199         }
 200
 201         if (Page_Uptodate(page)) {
 202                 CERROR("Explain this please?\n");
 203                 GOTO(readpage_out, rc);
 204         }
 205
 206         rc = ll_brw(OBD_BRW_READ, inode, page, 0);
 207         EXIT;
 208
 209  readpage_out:
 210         if (!rc)
 211                 SetPageUptodate(page);
 212         UnlockPage(page);
 213         return 0;
 214 } /* ll_readpage */
 215
 216
 217 static int ll_prepare_write(struct file *file, struct page *page, unsigned from,
 218                             unsigned to)
 219 {
 220         struct inode *inode = page->mapping->host;
 221         obd_off offset = ((obd_off)page->index) << PAGE_SHIFT;
 222         int rc = 0;
 223         char *addr;
 224         ENTRY;
 225
 226         addr = kmap(page);
 227         if (!PageLocked(page))
 228                 LBUG();
 229
 230         if (Page_Uptodate(page))
 231                 GOTO(prepare_done, rc);
 232
 233         if (offset + from >= inode->i_size) {
 234                 memset(addr, 0, PAGE_SIZE);
 235                 GOTO(prepare_done, rc);
 236         }
 237
 238         /* We're completely overwriting an existing page, so _don't_ set it up
 239          * to date until commit_write */
 240         if (from == 0 && to == PAGE_SIZE) {
 241                 memset(addr, 0, PAGE_SIZE);
 242                 RETURN(0);
 243         }
 244
 245         rc = ll_brw(OBD_BRW_READ, inode, page, 0);
 246
 247         EXIT;
 248  prepare_done:
 249         if (!rc)
 250                 SetPageUptodate(page);
 251
 252         return rc;
 253 }
 254
 255 /* returns the page unlocked, but with a reference */
 256 static int ll_writepage(struct page *page)
 257 {
 258         struct inode *inode = page->mapping->host;
 259         int err;
 260         ENTRY;
 261
 262         LBUG();
 263
 264         if (!PageLocked(page))
 265                 LBUG();
 266
 267         err = ll_brw(OBD_BRW_WRITE, inode, page, 1);
 268         if ( !err ) {
 269                 //SetPageUptodate(page);
 270                 set_page_clean(page);
 271         } else {
 272                 CERROR("ll_brw failure %d\n", err);
 273         }
 274         UnlockPage(page);
 275         RETURN(err);
 276 }
 277
 278 /* SYNCHRONOUS I/O to object storage for an inode -- object attr will be updated
 279  * too */
 280 static int ll_commit_write(struct file *file, struct page *page,
 281                            unsigned from, unsigned to)
 282 {
 283         int create = 1;
 284         struct inode *inode = page->mapping->host;
 285         obd_count        num_obdo = 1;
 286         obd_count        bufs_per_obdo = 1;
 287         struct obdo     *oa;
 288         obd_size         count = to;
 289         obd_off          offset = (((obd_off)page->index) << PAGE_SHIFT);
 290         obd_flag         flags = create ? OBD_BRW_CREATE : 0;
 291         int              err;
 292         struct iattr     iattr;
 293
 294         ENTRY;
 295         oa = ll_oa_from_inode(inode, OBD_MD_FLNOTOBD);
 296         if (! oa )
 297                 RETURN(-ENOMEM);
 298
 299         SetPageUptodate(page);
 300
 301         if (!PageLocked(page))
 302                 LBUG();
 303
 304         CDEBUG(D_INODE, "commit_page writing (at %d) to %d, count %Ld\n",
 305                from, to, (unsigned long long)count);
 306
 307         err = obd_brw(OBD_BRW_WRITE, ll_i2obdconn(inode), num_obdo, &oa,
 308                       &bufs_per_obdo, &page, &count, &offset, &flags);
 309         kunmap(page);
 310
 311         if (offset + to > inode->i_size) {
 312                 iattr.ia_valid = ATTR_SIZE;
 313                 iattr.ia_size = offset + to;
 314                 /* do NOT truncate */
 315                 inode->i_size = offset + to;
 316 #if 0
 317                 err = ll_inode_setattr(inode, &iattr, 0);
 318                 if (err) {
 319                         CERROR("failed - %d.\n", err);
 320                         err = -EIO;
 321                 }
 322 #endif
 323         }
 324
 325         obdo_free(oa);
 326         RETURN(err);
 327 } /* ll_commit_write */
 328
 329 void ll_truncate(struct inode *inode)
 330 {
 331         struct obdo *oa;
 332         int err;
 333         ENTRY;
 334
 335         oa = ll_oa_from_inode(inode, OBD_MD_FLNOTOBD);
 336         if ( !oa ) {
 337                 CERROR("no memory to allocate obdo!\n");
 338                 return;
 339         }
 340
 341         CDEBUG(D_INFO, "calling punch for %ld (%Lu bytes at 0)\n",
 342                (long)oa->o_id, (unsigned long long)oa->o_size);
 343         err = obd_punch(ll_i2obdconn(inode), oa, oa->o_size, 0);
 344         obdo_free(oa);
 345
 346         if (err) {
 347                 CERROR("obd_truncate fails (%d)\n", err);
 348         }
 349         EXIT;
 350         return;
 351 } /* ll_truncate */
 352
 353 int ll_direct_IO(int rw, struct inode * inode, struct kiobuf * iobuf, unsigned long blocknr, int blocksize)
 354 {
 355         int i;
 356         obd_count        num_obdo = 1;
 357         obd_count        bufs_per_obdo = iobuf->nr_pages;
 358         struct obdo     *oa = NULL;
 359         obd_size         *count = NULL;
 360         obd_off          *offset = NULL;
 361         obd_flag         *flags = NULL;
 362         int              err = 0;
 363
 364         ENTRY;
 365
 366         OBD_ALLOC(count, sizeof(obd_size) * bufs_per_obdo);
 367         if (!count)
 368                 GOTO(out, err=-ENOMEM);
 369
 370         OBD_ALLOC(offset, sizeof(obd_off) * bufs_per_obdo);
 371         if (!offset)
 372                 GOTO(out, err=-ENOMEM);
 373
 374         OBD_ALLOC(flags, sizeof(obd_flag) * bufs_per_obdo);
 375         if (!flags)
 376                 GOTO(out, err=-ENOMEM);
 377
 378         for (i = 0 ; i < bufs_per_obdo ; i++) {
 379                 count[i] = PAGE_SIZE;
 380                 offset[i] = ((obd_off)(iobuf->maplist[i])->index) << PAGE_SHIFT;
 381                 flags[i] = OBD_BRW_CREATE;
 382         }
 383
 384         oa = ll_oa_from_inode(inode, OBD_MD_FLNOTOBD);
 385         if (!oa)
 386                 RETURN(-ENOMEM);
 387
 388         err = obd_brw(rw, ll_i2obdconn(inode), num_obdo, &oa, &bufs_per_obdo,
 389                       iobuf->maplist, count, offset, flags);
 390         if (err == 0)
 391                 err = bufs_per_obdo * 4096;
 392
 393  out:
 394         if (oa)
 395                 obdo_free(oa);
 396         if (flags)
 397                 OBD_FREE(flags, sizeof(obd_flag) * bufs_per_obdo);
 398         if (count)
 399                 OBD_FREE(count, sizeof(obd_count) * bufs_per_obdo);
 400         if (offset)
 401                 OBD_FREE(offset, sizeof(obd_off) * bufs_per_obdo);
 402         RETURN(err);
 403 }
 404
 405
 406
 407 struct address_space_operations ll_aops = {
 408         readpage: ll_readpage,
 409         writepage: ll_writepage,
 410 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,17))
 411         direct_IO: ll_direct_IO,
 412 #endif
 413         sync_page: block_sync_page,
 414         prepare_write: ll_prepare_write,
 415         commit_write: ll_commit_write,
 416         bmap: NULL
 417 };