From 91736c8b6082fecb753c24e197c00dd1e2230f51 Mon Sep 17 00:00:00 2001 From: adilger Date: Tue, 29 Feb 2000 05:27:04 +0000 Subject: [PATCH] obdfs/flushd.c: send writes in FIFO order (use ->prev from list) don't get obdo until we have an actual I/O to do don't call _brw with zero pages to write obdfs/rw.c: set jiffies field in pgrq for new page cache entries obdfs/*.c: change debugging messages --- lustre/obdfs/file.c | 4 +- lustre/obdfs/flushd.c | 107 +++++++++++++++++++++++++++----------------------- lustre/obdfs/namei.c | 44 +++++++++++---------- lustre/obdfs/rw.c | 43 ++++++++++---------- lustre/obdfs/super.c | 11 +++--- 5 files changed, 111 insertions(+), 98 deletions(-) diff --git a/lustre/obdfs/file.c b/lustre/obdfs/file.c index 1bbb190..6492951 100644 --- a/lustre/obdfs/file.c +++ b/lustre/obdfs/file.c @@ -57,11 +57,11 @@ static ssize_t obdfs_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos) { ssize_t retval; - CDEBUG(D_INODE, "Writing inode %ld, %d bytes, offset %ld\n", file->f_dentry->d_inode->i_ino, count, (long)*ppos); + CDEBUG(D_INFO, "Writing inode %ld, %d bytes, offset %ld\n", file->f_dentry->d_inode->i_ino, count, (long)*ppos); retval = generic_file_write(file, buf, count, ppos, obdfs_write_one_page); - CDEBUG(D_INODE, "Wrote %d\n", retval); + CDEBUG(D_INFO, "Wrote %d\n", retval); if (retval > 0) { struct inode *inode = file->f_dentry->d_inode; remove_suid(inode); diff --git a/lustre/obdfs/flushd.c b/lustre/obdfs/flushd.c index 6d16cfc..52d7bd7 100644 --- a/lustre/obdfs/flushd.c +++ b/lustre/obdfs/flushd.c @@ -47,7 +47,8 @@ struct { int interval; /* jiffies delay between pupdate flushes */ int age_buffer; /* Time for normal buffer to age before we flush it */ int age_super; /* Time for superblock to age before we flush it */ -} pupd_prm = {40, 500, 64, 256, 2*HZ, 30*HZ, 5*HZ }; +/* } pupd_prm = {40, 500, 64, 256, 2*HZ, 30*HZ, 5*HZ }; */ +} pupd_prm = {40, 500, 64, 256, 10*HZ, 30*HZ, 5*HZ }; /* Called with the superblock list lock */ static int obdfs_enqueue_pages(struct inode *inode, struct obdo **obdo, @@ -60,19 +61,10 @@ static int obdfs_enqueue_pages(struct inode *inode, struct obdo **obdo, int num = 0; ENTRY; - OIDEBUG(inode); - - *obdo = obdo_fromid(IID(inode), inode->i_ino, OBD_MD_FLNOTOBD); - if ( IS_ERR(*obdo) ) { - EXIT; - return PTR_ERR(*obdo); - } - - obdfs_from_inode(*obdo, inode); /* FIXME revisit fromid & from_inode */ - *flag = OBD_BRW_CREATE; tmp = page_list; - while ( ((tmp = tmp->next) != page_list) && (num < nr_slots) ) { + /* Traverse list in reverse order, so we do FIFO, not LIFO order */ + while ( (tmp = tmp->prev) != page_list && num < nr_slots ) { struct obdfs_pgrq *req; struct page *page; @@ -82,14 +74,32 @@ static int obdfs_enqueue_pages(struct inode *inode, struct obdo **obdo, if (check_time && (jiffies - req->rq_jiffies) < pupd_prm.age_buffer) - continue; + continue; /* FIXME break; (pages are in order) */ + + /* Only allocate the obdo if we will actually do I/O here */ + if ( !*obdo ) { + OIDEBUG(inode); + *obdo = obdo_fromid(IID(inode), inode->i_ino, + OBD_MD_FLNOTOBD); + if ( IS_ERR(*obdo) ) { + int err = PTR_ERR(*obdo); + *obdo = NULL; + + EXIT; + return err; + } + + /* FIXME revisit fromid & from_inode */ + obdfs_from_inode(*obdo, inode); + *flag = OBD_BRW_CREATE; + } /* Remove request from list before write to avoid conflict. * Note that obdfs_pgrq_del() also deletes the request. */ obdfs_pgrq_del(req); if ( !page ) { - CDEBUG(D_INODE, "no page \n"); + CDEBUG(D_CACHE, "no page \n"); continue; } @@ -97,14 +107,14 @@ static int obdfs_enqueue_pages(struct inode *inode, struct obdo **obdo, pages[num] = page; counts[num] = PAGE_SIZE; offsets[num] = ((obd_off)page->index) << PAGE_SHIFT; - CDEBUG(D_INODE, "ENQ inode %ld, page %p addr %p to vector\n", + CDEBUG(D_INFO, "ENQ inode %ld, page %p addr %p to vector\n", inode->i_ino, page, (char *)page_address(page)); num++; } if (!list_empty(page_list)) - CDEBUG(D_INODE, "inode %ld list not empty\n", inode->i_ino); - CDEBUG(D_INODE, "added %d page(s) to vector\n", num); + CDEBUG(D_CACHE, "inode %ld list not empty\n", inode->i_ino); + CDEBUG(D_INFO, "added %d page(s) to vector\n", num); EXIT; return num; @@ -115,8 +125,8 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) { struct list_head *tmp; int total_io = 0; - obd_count num_io = 0; - obd_count num_obdos = 0; + obd_count num_io; + obd_count num_obdos; struct inode *inodes[MAX_IOVEC]; /* write data back to these */ struct page *pages[MAX_IOVEC]; /* call put_page on these */ struct obdo *obdos[MAX_IOVEC]; @@ -138,18 +148,21 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) sbi = list_entry(inode_list, struct obdfs_sb_info, osi_inodes); obd_down(&sbi->osi_list_mutex); - if ( list_empty(inode_list)) { - CDEBUG(D_INODE, "list empty\n"); + if ( list_empty(inode_list) ) { + CDEBUG(D_CACHE, "list empty\n"); obd_up(&sbi->osi_list_mutex); EXIT; return 0; } - /* add each inode's dirty pages to a write vector, and write it */ + /* Add each inode's dirty pages to a write vector, and write it. + * Traverse list in reverse order, so we do FIFO, not LIFO order + */ again: tmp = inode_list; - while ( (tmp = tmp->next) != inode_list && - total_io < pupd_prm.ndirty) { + num_io = 0; + num_obdos = 0; + while ( (tmp = tmp->prev) != inode_list && total_io < pupd_prm.ndirty) { struct obdfs_inode_info *ii; struct inode *inode; int res; @@ -157,17 +170,13 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) ii = list_entry(tmp, struct obdfs_inode_info, oi_inodes); inode = list_entry(ii, struct inode, u); inodes[num_obdos] = inode; - CDEBUG(D_INODE, "checking inode %ld pages\n", inode->i_ino); + obdos[num_obdos] = NULL; + CDEBUG(D_INFO, "checking inode %ld pages\n", inode->i_ino); - res = 1; - - /* Loop on this inode until we can't get more pages from it - * (either no more pages, or the pages aren't old enough). - * Make sure we reference "inode" and not "inodes[num_obdos]", + /* Make sure we reference "inode" and not "inodes[num_obdos]", * as num_obdos will change after the loop is run. */ - while (!list_empty(obdfs_iplist(inode)) && res && - total_io < pupd_prm.ndirty ) { + if (!list_empty(obdfs_iplist(inode))) { res = obdfs_enqueue_pages(inode, &obdos[num_obdos], MAX_IOVEC - num_io, &pages[num_io], &bufs[num_io], @@ -175,18 +184,18 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) &offsets[num_io], &flags[num_obdos], check_time); - CDEBUG(D_INODE, "FLUSHED inode %ld, pages flushed: %d\n", + CDEBUG(D_CACHE, "FLUSH inode %ld, pages flushed: %d\n", inode->i_ino, res); if ( res < 0 ) { - obd_up(&sbi->osi_list_mutex); err = res; - goto ERR; + EXIT; + goto BREAK; + } else if (res) { + num_io += res; + total_io += res; + bufs_per_obdo[num_obdos] = res; + num_obdos++; } - - num_io += res; - total_io += res; - bufs_per_obdo[num_obdos] = res; - num_obdos++; if ( num_io == MAX_IOVEC ) { obd_up(&sbi->osi_list_mutex); @@ -198,15 +207,13 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) EXIT; goto ERR; } - inodes[0] = inode; - num_io = 0; - num_obdos = 0; obd_down(&sbi->osi_list_mutex); goto again; } } } +BREAK: obd_up(&sbi->osi_list_mutex); /* flush any remaining I/Os */ @@ -214,6 +221,8 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) err = obdfs_do_vec_wr(inodes, num_io, num_obdos, obdos, bufs_per_obdo, pages, bufs, counts, offsets, flags); + num_io = 0; + num_obdos = 0; } /* Remove inode from superblock dirty list when no more pages. @@ -222,17 +231,17 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) */ obd_down(&sbi->osi_list_mutex); tmp = inode_list; - while ( (tmp = tmp->next) != inode_list ) { + while ( (tmp = tmp->prev) != inode_list ) { struct obdfs_inode_info *ii; struct inode *inode; ii = list_entry(tmp, struct obdfs_inode_info, oi_inodes); inode = list_entry(ii, struct inode, u); - CDEBUG(D_INODE, "checking inode %ld empty\n", inode->i_ino); + CDEBUG(D_INFO, "checking inode %ld empty\n", inode->i_ino); if (list_empty(obdfs_iplist(inode))) { - CDEBUG(D_INODE, "remove inode %ld from dirty list\n", + CDEBUG(D_CACHE, "remove inode %ld from dirty list\n", inode->i_ino); - tmp = tmp->prev; + tmp = tmp->next; list_del(obdfs_islist(inode)); /* decrement inode reference for page cache */ inode->i_count--; @@ -241,7 +250,7 @@ int obdfs_flush_reqs(struct list_head *inode_list, int check_time) } obd_up(&sbi->osi_list_mutex); - CDEBUG(D_INODE, "flushed %d pages in total\n", total_io); + CDEBUG(D_INFO, "flushed %d pages in total\n", total_io); EXIT; ERR: return err; @@ -254,7 +263,7 @@ void obdfs_flush_dirty_pages(int check_time) ENTRY; sl = &obdfs_super_list; - while ( (sl = sl->next) != &obdfs_super_list ) { + while ( (sl = sl->prev) != &obdfs_super_list ) { struct obdfs_sb_info *sbi = list_entry(sl, struct obdfs_sb_info, osi_list); diff --git a/lustre/obdfs/namei.c b/lustre/obdfs/namei.c index 87ddc55..6169217 100644 --- a/lustre/obdfs/namei.c +++ b/lustre/obdfs/namei.c @@ -79,7 +79,7 @@ static struct page * obdfs_find_entry (struct inode * dir, unsigned long offset; struct page * page; ENTRY; - CDEBUG(D_INODE, "find entry for %*s\n", namelen, name); + CDEBUG(D_INFO, "find entry for %*s\n", namelen, name); *res_dir = NULL; sb = dir->i_sb; @@ -87,7 +87,7 @@ static struct page * obdfs_find_entry (struct inode * dir, if (namelen > EXT2_NAME_LEN) return NULL; - CDEBUG(D_INODE, "dirsize is %Ld\n", dir->i_size); + CDEBUG(D_INFO, "dirsize is %Ld\n", dir->i_size); page = 0; offset = 0; @@ -98,7 +98,7 @@ static struct page * obdfs_find_entry (struct inode * dir, page = obdfs_getpage(dir, offset, 0, lock); if ( !page ) { - CDEBUG(D_INODE, "No page, offset %lx\n", offset); + CDEBUG(D_INFO, "No page, offset %lx\n", offset); return NULL; } @@ -108,7 +108,7 @@ static struct page * obdfs_find_entry (struct inode * dir, /* this code is executed quadratically often */ /* do minimal checking `by hand' */ int de_len; - /* CDEBUG(D_INODE, "Entry %p len %d, page at %#lx - %#lx , offset %lx\n", + /* CDEBUG(D_INFO, "Entry %p len %d, page at %#lx - %#lx , offset %lx\n", de, le16_to_cpu(de->rec_len), page_address(page), page_address(page) + PAGE_SIZE, offset); */ @@ -132,17 +132,17 @@ static struct page * obdfs_find_entry (struct inode * dir, offset += de_len; de = (struct ext2_dir_entry_2 *) ((char *) de + de_len); - /* CDEBUG(D_INODE, "Next while %lx\n", offset); */ + /* CDEBUG(D_INFO, "Next while %lx\n", offset); */ } if ( lock ) UnlockPage(page); page_cache_release(page); page = NULL; - CDEBUG(D_INODE, "Next for %lx\n", offset); + CDEBUG(D_INFO, "Next for %lx\n", offset); } failure: - CDEBUG(D_INODE, "Negative case, page %p, offset %ld\n", page, offset); + CDEBUG(D_INFO, "Negative case, page %p, offset %ld\n", page, offset); if (page) { if (lock) UnlockPage(page); @@ -166,7 +166,7 @@ struct dentry *obdfs_lookup(struct inode *dir, struct dentry *dentry) &de, LOCKED); inode = NULL; if ( !page ) - CDEBUG(D_INODE, "No page - negative entry.\n"); + CDEBUG(D_INFO, "No page - negative entry.\n"); if ( page && !de ) { CDEBUG(D_INODE, "Danger: PAGE but de.\n"); return ERR_PTR(-ENOENT); @@ -221,12 +221,14 @@ static struct page *obdfs_add_entry (struct inode * dir, *err = -EINVAL; *res_dir = NULL; if (!dir || !dir->i_nlink) { + CDEBUG(D_INODE, "bad directory\n"); EXIT; return NULL; } sb = dir->i_sb; if (!namelen) { + CDEBUG(D_INODE, "bad directory\n"); EXIT; return NULL; } @@ -246,13 +248,13 @@ static struct page *obdfs_add_entry (struct inode * dir, return NULL; } rec_len = EXT2_DIR_REC_LEN(namelen); - /* CDEBUG(D_INODE, "reclen: %d\n", rec_len); */ + /* CDEBUG(D_INFO, "reclen: %d\n", rec_len); */ PDEBUG(page, "starting search"); offset = 0; de = (struct ext2_dir_entry_2 *) page_address(page); *err = -ENOSPC; while (1) { - /* CDEBUG(D_INODE, + /* CDEBUG(D_INFO, "Entry at %p, (page at %#lx - %#lx), offset %ld\n", de, page_address(page), page_address(page) + PAGE_SIZE, offset); */ @@ -272,7 +274,7 @@ static struct page *obdfs_add_entry (struct inode * dir, return NULL; } - CDEBUG(D_INODE, "creating next block\n"); + CDEBUG(D_INFO, "creating next block\n"); de = (struct ext2_dir_entry_2 *) page_address(page); de->inode = 0; @@ -295,7 +297,7 @@ static struct page *obdfs_add_entry (struct inode * dir, EXIT; return NULL; } - CDEBUG(D_INODE, "\n"); + CDEBUG(D_INFO, "\n"); if (ext2_match (namelen, name, de)) { *err = -EEXIST; UnlockPage(page); @@ -303,24 +305,24 @@ static struct page *obdfs_add_entry (struct inode * dir, EXIT; return NULL; } - /* CDEBUG(D_INODE, "Testing for enough space at de %p\n", de);*/ + /* CDEBUG(D_INFO, "Testing for enough space at de %p\n", de);*/ if ( (le32_to_cpu(de->inode) == 0 && le16_to_cpu(de->rec_len) >= rec_len) || (le16_to_cpu(de->rec_len) >= EXT2_DIR_REC_LEN(de->name_len) + rec_len)) { offset += le16_to_cpu(de->rec_len); - /* CDEBUG(D_INODE, + /* CDEBUG(D_INFO, "Found enough space de %p, offset %#lx\n", de, offset); */ if (le32_to_cpu(de->inode)) { - /*CDEBUG(D_INODE, "Insert new in %p\n", de);*/ + /*CDEBUG(D_INFO, "Insert new in %p\n", de);*/ de1 = (struct ext2_dir_entry_2 *) ((char *) de + EXT2_DIR_REC_LEN(de->name_len)); - /*CDEBUG(D_INODE, "-- de1 at %p\n", de1);*/ + /*CDEBUG(D_INFO, "-- de1 at %p\n", de1);*/ de1->rec_len = cpu_to_le16(le16_to_cpu(de->rec_len) - EXT2_DIR_REC_LEN(de->name_len)); de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len)); de = de1; } - /* CDEBUG(D_INODE, + /* CDEBUG(D_INFO, "Reclen adjusted; copy %d bytes to %p, " "page at %#lx EOP at %#lx\n", namelen, de->name, page_address(page), @@ -877,7 +879,7 @@ int obdfs_symlink (struct inode * dir, struct dentry *dentry, oinfo = obdfs_i2info(inode); if (l >= sizeof(oinfo->oi_inline)) { - CDEBUG(D_INODE, "l=%d, normal symlink\n", l); + CDEBUG(D_INFO, "l=%d, normal symlink\n", l); name_page = obdfs_getpage(inode, 0, 1, LOCKED); if (!name_page) { @@ -892,7 +894,7 @@ int obdfs_symlink (struct inode * dir, struct dentry *dentry, link = oinfo->oi_inline; oinfo->oi_flags |= OBD_FL_INLINEDATA; - CDEBUG(D_INODE, "l=%d, fast symlink\n", l); + CDEBUG(D_INFO, "l=%d, fast symlink\n", l); } i = 0; while (i < inode->i_sb->s_blocksize - 1 && (c = *(symname++))) @@ -1083,11 +1085,11 @@ int obdfs_rename (struct inode * old_dir, struct dentry *old_dentry, if ( old_page != new_page ) { unsigned long index = old_page->index; /* lock the old_page and release unlocked copy */ - CDEBUG(D_INODE, "old_page at %p\n", old_page); + CDEBUG(D_INFO, "old_page at %p\n", old_page); page_cache_release(old_page); old_page = obdfs_getpage(old_dir, index << PAGE_SHIFT, 0, LOCKED); - CDEBUG(D_INODE, "old_page at %p\n", old_page); + CDEBUG(D_INFO, "old_page at %p\n", old_page); err = obdfs_do_writepage(old_dir, old_page, IS_SYNC(old_dir)); /* XXX handle err */ } diff --git a/lustre/obdfs/rw.c b/lustre/obdfs/rw.c index 5bd837e..ba8c2f1 100644 --- a/lustre/obdfs/rw.c +++ b/lustre/obdfs/rw.c @@ -93,7 +93,7 @@ int obdfs_init_pgrqcache(void) { ENTRY; if (obdfs_pgrq_cachep == NULL) { - CDEBUG(D_INODE, "allocating obdfs_pgrq_cache\n"); + CDEBUG(D_CACHE, "allocating obdfs_pgrq_cache\n"); obdfs_pgrq_cachep = kmem_cache_create("obdfs_pgrq", sizeof(struct obdfs_pgrq), 0, SLAB_HWCACHE_ALIGN, @@ -102,11 +102,11 @@ int obdfs_init_pgrqcache(void) EXIT; return -ENOMEM; } else { - CDEBUG(D_INODE, "allocated cache at %p\n", + CDEBUG(D_CACHE, "allocated cache at %p\n", obdfs_pgrq_cachep); } } else { - CDEBUG(D_INODE, "using existing cache at %p\n", + CDEBUG(D_CACHE, "using existing cache at %p\n", obdfs_pgrq_cachep); } EXIT; @@ -116,7 +116,7 @@ int obdfs_init_pgrqcache(void) inline void obdfs_pgrq_del(struct obdfs_pgrq *pgrq) { obdfs_cache_count--; - CDEBUG(D_INODE, "deleting page %p from list [count %d]\n", + CDEBUG(D_INFO, "deleting page %p from list [count %d]\n", pgrq->rq_page, obdfs_cache_count); list_del(&pgrq->rq_plist); kmem_cache_free(obdfs_pgrq_cachep, pgrq); @@ -126,7 +126,7 @@ void obdfs_cleanup_pgrqcache(void) { ENTRY; if (obdfs_pgrq_cachep != NULL) { - CDEBUG(D_INODE, "destroying obdfs_pgrqcache at %p, count %d\n", + CDEBUG(D_CACHE, "destroying obdfs_pgrqcache at %p, count %d\n", obdfs_pgrq_cachep, obdfs_cache_count); if (kmem_cache_destroy(obdfs_pgrq_cachep)) printk(KERN_INFO __FUNCTION__ @@ -152,11 +152,11 @@ obdfs_find_in_page_list(struct inode *inode, struct page *page) ENTRY; - CDEBUG(D_INODE, "looking for inode %ld page %p\n", inode->i_ino, page); + CDEBUG(D_INFO, "looking for inode %ld page %p\n", inode->i_ino, page); OIDEBUG(inode); if (list_empty(page_list)) { - CDEBUG(D_INODE, "empty list\n"); + CDEBUG(D_INFO, "empty list\n"); EXIT; return NULL; } @@ -166,7 +166,7 @@ obdfs_find_in_page_list(struct inode *inode, struct page *page) pgrq = list_entry(tmp, struct obdfs_pgrq, rq_plist); if (pgrq->rq_page == page) { - CDEBUG(D_INODE, "found page %p in list\n", page); + CDEBUG(D_INFO, "found page %p in list\n", page); EXIT; return pgrq; } @@ -187,7 +187,7 @@ static struct page* obdfs_find_page_index(struct inode *inode, ENTRY; - CDEBUG(D_INODE, "looking for inode %ld pageindex %ld\n", + CDEBUG(D_INFO, "looking for inode %ld pageindex %ld\n", inode->i_ino, index); OIDEBUG(inode); @@ -202,7 +202,7 @@ static struct page* obdfs_find_page_index(struct inode *inode, pgrq = list_entry(tmp, struct obdfs_pgrq, rq_plist); page = pgrq->rq_page; if (index == page->index) { - CDEBUG(D_INODE, + CDEBUG(D_INFO, "INDEX SEARCH found page %p, index %ld\n", page, index); EXIT; @@ -226,7 +226,7 @@ int obdfs_do_vec_wr(struct inode **inodes, obd_count num_io, int err; ENTRY; - CDEBUG(D_INODE, "writing %d page(s), %d obdo(s) in vector\n", + CDEBUG(D_INFO, "writing %d page(s), %d obdo(s) in vector\n", num_io, num_obdos); err = OPS(sb, brw)(WRITE, &sbi->osi_conn, num_obdos, obdos, oa_bufs, bufs, counts, offsets, flags); @@ -234,14 +234,14 @@ int obdfs_do_vec_wr(struct inode **inodes, obd_count num_io, /* release the pages from the page cache */ while ( num_io > 0 ) { num_io--; - CDEBUG(D_INODE, "calling put_page for %p, index %ld\n", + CDEBUG(D_INFO, "calling put_page for %p, index %ld\n", pages[num_io], pages[num_io]->index); put_page(pages[num_io]); } while ( num_obdos > 0) { num_obdos--; - CDEBUG(D_INODE, "copy/free obdo %ld\n", + CDEBUG(D_INFO, "copy/free obdo %ld\n", (long)obdos[num_obdos]->o_id); obdfs_to_inode(inodes[num_obdos], obdos[num_obdos]); obdo_free(obdos[num_obdos]); @@ -266,8 +266,9 @@ static int obdfs_add_page_to_cache(struct inode *inode, struct page *page) if ( !obdfs_find_in_page_list(inode, page) ) { struct obdfs_pgrq *pgrq; pgrq = kmem_cache_alloc(obdfs_pgrq_cachep, SLAB_KERNEL); - CDEBUG(D_INODE, "adding inode %ld page %p, pgrq: %p, cache count [%d]\n", - inode->i_ino, page, pgrq, obdfs_cache_count); + CDEBUG(D_INFO, + "adding inode %ld page %p, pgrq: %p, cache count [%d]\n", + inode->i_ino, page, pgrq, obdfs_cache_count + 1); if (!pgrq) { EXIT; obd_up(&obdfs_i2sbi(inode)->osi_list_mutex); @@ -276,6 +277,7 @@ static int obdfs_add_page_to_cache(struct inode *inode, struct page *page) memset(pgrq, 0, sizeof(*pgrq)); pgrq->rq_page = page; + pgrq->rq_jiffies = jiffies; get_page(pgrq->rq_page); list_add(&pgrq->rq_plist, obdfs_iplist(inode)); obdfs_cache_count++; @@ -293,7 +295,7 @@ static int obdfs_add_page_to_cache(struct inode *inode, struct page *page) */ if ( list_empty(obdfs_islist(inode)) ) { inode->i_count++; - CDEBUG(D_INODE, "adding inode %ld to superblock list %p\n", + CDEBUG(D_INFO, "adding inode %ld to superblock list %p\n", inode->i_ino, obdfs_slist(inode)); list_add(obdfs_islist(inode), obdfs_slist(inode)); } @@ -321,7 +323,8 @@ int obdfs_do_writepage(struct inode *inode, struct page *page, int sync) err = obdfs_brw(WRITE, inode, page, 1); else { err = obdfs_add_page_to_cache(inode, page); - CDEBUG(D_IOCTL, "DO_WR ino: %ld, page %p, err %d, uptodate %d\n", inode->i_ino, page, err, Page_Uptodate(page)); + CDEBUG(D_INFO, "DO_WR ino: %ld, page %p, err %d, uptodate %d\n", + inode->i_ino, page, err, Page_Uptodate(page)); } if ( !err ) @@ -394,7 +397,7 @@ struct page *obdfs_getpage(struct inode *inode, unsigned long offset, ENTRY; offset = offset & PAGE_CACHE_MASK; - CDEBUG(D_INODE, "ino: %ld, offset %ld, create %d, locked %d\n", + CDEBUG(D_INFO, "ino: %ld, offset %ld, create %d, locked %d\n", inode->i_ino, offset, create, locked); index = offset >> PAGE_CACHE_SHIFT; @@ -405,7 +408,7 @@ struct page *obdfs_getpage(struct inode *inode, unsigned long offset, EXIT; return NULL; } - CDEBUG(D_INODE, "page_cache %p\n", page_cache); + CDEBUG(D_INFO, "page_cache %p\n", page_cache); hash = page_hash(&inode->i_data, index); page = grab_cache_page(&inode->i_data, index); @@ -428,7 +431,7 @@ struct page *obdfs_getpage(struct inode *inode, unsigned long offset, if ( obdfs_find_page_index(inode, index) ) { - CDEBUG(D_INODE, "OVERWRITE: found dirty page %p, index %ld\n", + CDEBUG(D_INFO, "OVERWRITE: found dirty page %p, index %ld\n", page, page->index); } diff --git a/lustre/obdfs/super.c b/lustre/obdfs/super.c index 3fe0f78..18623de 100644 --- a/lustre/obdfs/super.c +++ b/lustre/obdfs/super.c @@ -40,7 +40,7 @@ static char *obdfs_read_opt(const char *opt, char *data) char *value; char *retval; - CDEBUG(D_SUPER, "option: %s, data %s\n", opt, data); + CDEBUG(D_INFO, "option: %s, data %s\n", opt, data); if ( strncmp(opt, data, strlen(opt)) ) return NULL; @@ -55,7 +55,7 @@ static char *obdfs_read_opt(const char *opt, char *data) } memcpy(retval, value, strlen(value)+1); - CDEBUG(D_SUPER, "Assigned option: %s, value %s\n", opt, retval); + CDEBUG(D_INFO, "Assigned option: %s, value %s\n", opt, retval); return retval; } @@ -69,7 +69,7 @@ static void obdfs_options(char *options, char **dev, char **vers) for (this_char = strtok (options, ","); this_char != NULL; this_char = strtok (NULL, ",")) { - CDEBUG(D_SUPER, "this_char %s\n", this_char); + CDEBUG(D_INFO, "this_char %s\n", this_char); if ( (!*dev && (*dev = obdfs_read_opt("device", this_char)))|| (!*vers && (*vers = obdfs_read_opt("version", this_char))) ) continue; @@ -221,7 +221,7 @@ static struct super_block * obdfs_read_super(struct super_block *sb, goto ERR; } - CDEBUG(D_SUPER, "obdfs_read_super: sbdev %d, rootino: %ld, dev %s, " + CDEBUG(D_INFO, "obdfs_read_super: sbdev %d, rootino: %ld, dev %s, " "minor: %d, blocksize: %ld, blocksize bits %ld\n", sb->s_dev, root->i_ino, device, MINOR(devno), blocksize, blocksize_bits); @@ -358,8 +358,7 @@ static void obdfs_put_inode(struct inode *inode) obd_down(&obdfs_i2sbi(inode)->osi_list_mutex); tmp = obdfs_islist(inode); if ( list_empty(tmp) ) { - CDEBUG(D_INODE, __FUNCTION__ ": no dirty pages for inode %ld\n", - inode->i_ino); + CDEBUG(D_INFO, "no dirty pages for inode %ld\n", inode->i_ino); obd_up(&obdfs_i2sbi(inode)->osi_list_mutex); EXIT; return; -- 1.8.3.1