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