X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Fllite_lib.c;h=0a4db55018c342928087adbeb957f6ae00679ac2;hp=c39ecab289e08469ca95872e026b21642240f94d;hb=8cad1d968ad4efee46d08aee1e6a6266d4713e84;hpb=58a916eb05e54304d20af13f18d7810cd465f2d7 diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index c39ecab..0a4db55 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -26,7 +26,7 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. */ /* @@ -42,7 +42,6 @@ #include #include -#include #include #include @@ -59,14 +58,14 @@ cfs_mem_cache_t *ll_file_data_slab; -LIST_HEAD(ll_super_blocks); -spinlock_t ll_sb_lock = SPIN_LOCK_UNLOCKED; +CFS_LIST_HEAD(ll_super_blocks); +cfs_spinlock_t ll_sb_lock = CFS_SPIN_LOCK_UNLOCKED; extern struct address_space_operations ll_aops; extern struct address_space_operations ll_dir_aops; #ifndef log2 -#define log2(n) ffz(~(n)) +#define log2(n) cfs_ffz(~(n)) #endif static struct ll_sb_info *ll_init_sbi(void) @@ -82,10 +81,10 @@ static struct ll_sb_info *ll_init_sbi(void) if (!sbi) RETURN(NULL); - spin_lock_init(&sbi->ll_lock); - spin_lock_init(&sbi->ll_lco.lco_lock); - spin_lock_init(&sbi->ll_pp_extent_lock); - spin_lock_init(&sbi->ll_process_lock); + cfs_spin_lock_init(&sbi->ll_lock); + cfs_init_mutex(&sbi->ll_lco.lco_lock); + cfs_spin_lock_init(&sbi->ll_pp_extent_lock); + cfs_spin_lock_init(&sbi->ll_process_lock); sbi->ll_rw_stats_on = 0; si_meminfo(&si); @@ -105,18 +104,18 @@ static struct ll_sb_info *ll_init_sbi(void) sbi->ll_ra_info.ra_max_pages = sbi->ll_ra_info.ra_max_pages_per_file; sbi->ll_ra_info.ra_max_read_ahead_whole_pages = SBI_DEFAULT_READAHEAD_WHOLE_MAX; - INIT_LIST_HEAD(&sbi->ll_conn_chain); - INIT_LIST_HEAD(&sbi->ll_orphan_dentry_list); + CFS_INIT_LIST_HEAD(&sbi->ll_conn_chain); + CFS_INIT_LIST_HEAD(&sbi->ll_orphan_dentry_list); ll_generate_random_uuid(uuid); class_uuid_unparse(uuid, &sbi->ll_sb_uuid); CDEBUG(D_CONFIG, "generated uuid: %s\n", sbi->ll_sb_uuid.uuid); - spin_lock(&ll_sb_lock); - list_add_tail(&sbi->ll_list, &ll_super_blocks); - spin_unlock(&ll_sb_lock); + cfs_spin_lock(&ll_sb_lock); + cfs_list_add_tail(&sbi->ll_list, &ll_super_blocks); + cfs_spin_unlock(&ll_sb_lock); -#ifdef ENABLE_LLITE_CHECKSUM +#ifdef ENABLE_CHECKSUM sbi->ll_flags |= LL_SBI_CHECKSUM; #endif @@ -124,17 +123,17 @@ static struct ll_sb_info *ll_init_sbi(void) sbi->ll_flags |= LL_SBI_LRU_RESIZE; #endif -#ifdef HAVE_EXPORT___IGET - INIT_LIST_HEAD(&sbi->ll_deathrow); - spin_lock_init(&sbi->ll_deathrow_lock); -#endif for (i = 0; i <= LL_PROCESS_HIST_MAX; i++) { - spin_lock_init(&sbi->ll_rw_extents_info.pp_extents[i].pp_r_hist.oh_lock); - spin_lock_init(&sbi->ll_rw_extents_info.pp_extents[i].pp_w_hist.oh_lock); + cfs_spin_lock_init(&sbi->ll_rw_extents_info.pp_extents[i]. \ + pp_r_hist.oh_lock); + cfs_spin_lock_init(&sbi->ll_rw_extents_info.pp_extents[i]. \ + pp_w_hist.oh_lock); } /* metadata statahead is enabled by default */ sbi->ll_sa_max = LL_SA_RPC_DEF; + atomic_set(&sbi->ll_sa_total, 0); + atomic_set(&sbi->ll_sa_wrong, 0); RETURN(sbi); } @@ -145,9 +144,9 @@ void ll_free_sbi(struct super_block *sb) ENTRY; if (sbi != NULL) { - spin_lock(&ll_sb_lock); - list_del(&sbi->ll_list); - spin_unlock(&ll_sb_lock); + cfs_spin_lock(&ll_sb_lock); + cfs_list_del(&sbi->ll_list); + cfs_spin_unlock(&ll_sb_lock); OBD_FREE(sbi, sizeof(*sbi)); } EXIT; @@ -168,6 +167,7 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) struct ptlrpc_request *request = NULL; struct obd_connect_data *data = NULL; struct obd_uuid *uuid; + struct md_op_data *op_data; struct lustre_md lmd; obd_valid valid; int size, err, checksum; @@ -197,7 +197,10 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) OBD_CONNECT_OSS_CAPA | OBD_CONNECT_CANCELSET| OBD_CONNECT_FID | OBD_CONNECT_AT | OBD_CONNECT_LOV_V3 | OBD_CONNECT_RMT_CLIENT | - OBD_CONNECT_VBR | OBD_CONNECT_SOM; + OBD_CONNECT_VBR | OBD_CONNECT_FULL20; + + if (sbi->ll_flags & LL_SBI_SOM_PREVIEW) + data->ocd_connect_flags |= OBD_CONNECT_SOM; #ifdef HAVE_LRU_RESIZE_SUPPORT if (sbi->ll_flags & LL_SBI_LRU_RESIZE) @@ -250,7 +253,8 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) GOTO(out_md, err); } - err = obd_statfs(obd, &osfs, cfs_time_current_64() - HZ, 0); + err = obd_statfs(obd, &osfs, + cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), 0); if (err) GOTO(out_md_fid, err); @@ -274,7 +278,7 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) * * it will check if *ppos is greater than max. However, max equals to * s_maxbytes, which is a negative integer in a x86_64 box since loff_t - * has been defined as a signed long long ineger in linux kernel. */ + * has been defined as a signed long long integer in linux kernel. */ #if BITS_PER_LONG == 64 sb->s_maxbytes = PAGE_CACHE_MAXBYTES >> 1; #else @@ -303,9 +307,6 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) sbi->ll_flags &= ~LL_SBI_ACL; } - if (data->ocd_connect_flags & OBD_CONNECT_JOIN) - sbi->ll_flags |= LL_SBI_JOIN; - if (data->ocd_connect_flags & OBD_CONNECT_RMT_CLIENT) { if (!(sbi->ll_flags & LL_SBI_RMT_CLIENT)) { sbi->ll_flags |= LL_SBI_RMT_CLIENT; @@ -341,7 +342,10 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) OBD_CONNECT_SRVLOCK | OBD_CONNECT_TRUNCLOCK| OBD_CONNECT_AT | OBD_CONNECT_RMT_CLIENT | OBD_CONNECT_OSS_CAPA | OBD_CONNECT_VBR| - OBD_CONNECT_SOM; + OBD_CONNECT_FULL20; + + if (sbi->ll_flags & LL_SBI_SOM_PREVIEW) + data->ocd_connect_flags |= OBD_CONNECT_SOM; if (!OBD_FAIL_CHECK(OBD_FAIL_OSC_CONNECT_CKSUM)) { /* OBD_CONNECT_CKSUM should always be set, even if checksums are @@ -390,11 +394,11 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) GOTO(out_dt, err); } - spin_lock(&sbi->ll_lco.lco_lock); + cfs_mutex_down(&sbi->ll_lco.lco_lock); sbi->ll_lco.lco_flags = data->ocd_connect_flags; sbi->ll_lco.lco_md_exp = sbi->ll_md_exp; sbi->ll_lco.lco_dt_exp = sbi->ll_dt_exp; - spin_unlock(&sbi->ll_lco.lco_lock); + cfs_mutex_up(&sbi->ll_lco.lco_lock); fid_zero(&sbi->ll_root_fid); err = md_getstatus(sbi->ll_md_exp, &sbi->ll_root_fid, &oc); @@ -409,7 +413,9 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) CDEBUG(D_SUPER, "rootfid "DFID"\n", PFID(&sbi->ll_root_fid)); sb->s_op = &lustre_super_operations; +#if THREAD_SIZE >= 8192 sb->s_export_op = &lustre_export_operations; +#endif /* make root inode * XXX: move this to after cbd setup? */ @@ -419,10 +425,19 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) else if (sbi->ll_flags & LL_SBI_ACL) valid |= OBD_MD_FLACL; - err = md_getattr(sbi->ll_md_exp, &sbi->ll_root_fid, oc, valid, 0, - &request); + OBD_ALLOC_PTR(op_data); + if (op_data == NULL) + GOTO(out_lock_cn_cb, err = -ENOMEM); + + op_data->op_fid1 = sbi->ll_root_fid; + op_data->op_mode = 0; + op_data->op_capa1 = oc; + op_data->op_valid = valid; + + err = md_getattr(sbi->ll_md_exp, op_data, &request); if (oc) capa_put(oc); + OBD_FREE_PTR(op_data); if (err) { CERROR("md_getattr failed for root: rc = %d\n", err); GOTO(out_lock_cn_cb, err); @@ -437,7 +452,7 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) } LASSERT(fid_is_sane(&sbi->ll_root_fid)); - root = ll_iget(sb, ll_fid_build_ino(sbi, &sbi->ll_root_fid), &lmd); + root = ll_iget(sb, cl_fid_build_ino(&sbi->ll_root_fid), &lmd); md_free_lustre_md(sbi->ll_md_exp, &lmd); ptlrpc_req_finished(request); @@ -530,26 +545,16 @@ int ll_get_max_mdsize(struct ll_sb_info *sbi, int *lmmsize) void ll_dump_inode(struct inode *inode) { struct list_head *tmp; - struct dentry *dentry; int dentry_count = 0; LASSERT(inode != NULL); - CERROR("inode %p dump: dev=%s ino=%lu mode=%o count=%u state %lx\n", - inode, ll_i2mdexp(inode)->exp_obd->obd_name, inode->i_ino, - inode->i_mode, atomic_read(&inode->i_count), inode->i_state); - - list_for_each(tmp, &inode->i_dentry) { - dentry = list_entry(tmp, struct dentry, d_alias); - CERROR("Alias[%d] dentry %p dump: name=%.*s parent=%.*s (%p), inode=%p, count=%u, " - "flags=0x%x, fsdata=%p\n", dentry_count, dentry, - dentry->d_name.len, dentry->d_name.name, - dentry->d_parent->d_name.len, dentry->d_parent->d_name.name, - dentry->d_parent, dentry->d_inode, atomic_read(&dentry->d_count), - dentry->d_flags, dentry->d_fsdata); + list_for_each(tmp, &inode->i_dentry) dentry_count++; - } + CERROR("inode %p dump: dev=%s ino=%lu mode=%o count=%u, %d dentries\n", + inode, ll_i2mdexp(inode)->exp_obd->obd_name, inode->i_ino, + inode->i_mode, atomic_read(&inode->i_count), dentry_count); } void lustre_dump_dentry(struct dentry *dentry, int recur) @@ -574,109 +579,12 @@ void lustre_dump_dentry(struct dentry *dentry, int recur) if (recur == 0) return; - list_for_each(tmp, &dentry->d_subdirs) { + list_for_each(tmp, &dentry->d_subdirs) { struct dentry *d = list_entry(tmp, struct dentry, d_child); lustre_dump_dentry(d, recur - 1); } } -#ifdef HAVE_EXPORT___IGET -static void prune_dir_dentries(struct inode *inode) -{ - struct dentry *dentry, *prev = NULL; - - /* due to lustre specific logic, a directory - * can have few dentries - a bug from VFS POV */ -restart: - spin_lock(&dcache_lock); - if (!list_empty(&inode->i_dentry)) { - dentry = list_entry(inode->i_dentry.prev, - struct dentry, d_alias); - /* in order to prevent infinite loops we - * break if previous dentry is busy */ - if (dentry != prev) { - prev = dentry; - dget_locked(dentry); - spin_unlock(&dcache_lock); - - /* try to kill all child dentries */ - lock_dentry(dentry); - shrink_dcache_parent(dentry); - unlock_dentry(dentry); - dput(dentry); - - /* now try to get rid of current dentry */ - d_prune_aliases(inode); - goto restart; - } - } - spin_unlock(&dcache_lock); -} - -static void prune_deathrow_one(struct ll_inode_info *lli) -{ - struct inode *inode = ll_info2i(lli); - - /* first, try to drop any dentries - they hold a ref on the inode */ - if (S_ISDIR(inode->i_mode)) - prune_dir_dentries(inode); - else - d_prune_aliases(inode); - - - /* if somebody still uses it, leave it */ - LASSERT(atomic_read(&inode->i_count) > 0); - if (atomic_read(&inode->i_count) > 1) - goto out; - - CDEBUG(D_INODE, "inode %lu/%u(%d) looks a good candidate for prune\n", - inode->i_ino,inode->i_generation, atomic_read(&inode->i_count)); - - /* seems nobody uses it anymore */ - inode->i_nlink = 0; - -out: - iput(inode); - return; -} - -static void prune_deathrow(struct ll_sb_info *sbi, int try) -{ - struct ll_inode_info *lli; - int empty; - - do { - if (need_resched() && try) - break; - - if (try) { - if (!spin_trylock(&sbi->ll_deathrow_lock)) - break; - } else { - spin_lock(&sbi->ll_deathrow_lock); - } - - empty = 1; - lli = NULL; - if (!list_empty(&sbi->ll_deathrow)) { - lli = list_entry(sbi->ll_deathrow.next, - struct ll_inode_info, - lli_dead_list); - list_del_init(&lli->lli_dead_list); - if (!list_empty(&sbi->ll_deathrow)) - empty = 0; - } - spin_unlock(&sbi->ll_deathrow_lock); - - if (lli) - prune_deathrow_one(lli); - - } while (empty == 0); -} -#else /* !HAVE_EXPORT___IGET */ -#define prune_deathrow(sbi, try) do {} while (0) -#endif /* HAVE_EXPORT___IGET */ - void client_common_put_super(struct super_block *sb) { struct ll_sb_info *sbi = ll_s2sbi(sb); @@ -695,10 +603,7 @@ void client_common_put_super(struct super_block *sb) cl_sb_fini(sb); - /* destroy inodes in deathrow */ - prune_deathrow(sbi, 0); - - list_del(&sbi->ll_conn_chain); + cfs_list_del(&sbi->ll_conn_chain); obd_fid_fini(sbi->ll_dt_exp); obd_disconnect(sbi->ll_dt_exp); @@ -808,17 +713,25 @@ static int ll_options(char *options, int *flags) *flags &= ~tmp; goto next; } +#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2,5,50,0) tmp = ll_set_opt("acl", s1, LL_SBI_ACL); if (tmp) { /* Ignore deprecated mount option. The client will * always try to mount with ACL support, whether this * is used depends on whether server supports it. */ + LCONSOLE_ERROR_MSG(0x152, "Ignoring deprecated " + "mount option 'acl'.\n"); goto next; } tmp = ll_set_opt("noacl", s1, LL_SBI_ACL); if (tmp) { + LCONSOLE_ERROR_MSG(0x152, "Ignoring deprecated " + "mount option 'noacl'.\n"); goto next; } +#else +#warning "{no}acl options have been deprecated since 1.8, please remove them" +#endif tmp = ll_set_opt("remote_client", s1, LL_SBI_RMT_CLIENT); if (tmp) { *flags |= tmp; @@ -855,6 +768,16 @@ static int ll_options(char *options, int *flags) *flags &= ~tmp; goto next; } + tmp = ll_set_opt("som_preview", s1, LL_SBI_SOM_PREVIEW); + if (tmp) { + *flags |= tmp; + goto next; + } + tmp = ll_set_opt("32bitapi", s1, LL_SBI_32BIT_API); + if (tmp) { + *flags |= tmp; + goto next; + } LCONSOLE_ERROR_MSG(0x152, "Unknown option '%s', won't mount.\n", s1); @@ -873,23 +796,26 @@ next: void ll_lli_init(struct ll_inode_info *lli) { lli->lli_inode_magic = LLI_INODE_MAGIC; - sema_init(&lli->lli_size_sem, 1); - sema_init(&lli->lli_write_sem, 1); + cfs_sema_init(&lli->lli_size_sem, 1); + cfs_sema_init(&lli->lli_write_sem, 1); + cfs_sema_init(&lli->lli_trunc_sem, 1); lli->lli_flags = 0; lli->lli_maxbytes = PAGE_CACHE_MAXBYTES; - spin_lock_init(&lli->lli_lock); - INIT_LIST_HEAD(&lli->lli_close_list); + cfs_spin_lock_init(&lli->lli_lock); + CFS_INIT_LIST_HEAD(&lli->lli_close_list); lli->lli_inode_magic = LLI_INODE_MAGIC; - sema_init(&lli->lli_och_sem, 1); + cfs_sema_init(&lli->lli_och_sem, 1); lli->lli_mds_read_och = lli->lli_mds_write_och = NULL; lli->lli_mds_exec_och = NULL; lli->lli_open_fd_read_count = lli->lli_open_fd_write_count = 0; lli->lli_open_fd_exec_count = 0; - INIT_LIST_HEAD(&lli->lli_dead_list); + CFS_INIT_LIST_HEAD(&lli->lli_dead_list); lli->lli_remote_perms = NULL; lli->lli_rmtperm_utime = 0; - sema_init(&lli->lli_rmtperm_sem, 1); - INIT_LIST_HEAD(&lli->lli_oss_capas); + cfs_sema_init(&lli->lli_rmtperm_sem, 1); + CFS_INIT_LIST_HEAD(&lli->lli_oss_capas); + cfs_spin_lock_init(&lli->lli_sa_lock); + CFS_INIT_LIST_HEAD(&lli->lli_sa_dentry); } int ll_fill_super(struct super_block *sb) @@ -911,7 +837,7 @@ int ll_fill_super(struct super_block *sb) /* client additional sb info */ lsi->lsi_llsbi = sbi = ll_init_sbi(); if (!sbi) { - cfs_module_put(); + cfs_module_put(THIS_MODULE); RETURN(-ENOMEM); } @@ -933,6 +859,7 @@ int ll_fill_super(struct super_block *sb) GOTO(out_free, err); } + /* Profile set with LCFG_MOUNTOPT so we can find our mdc and osc obds */ lprof = class_get_profile(profilenm); if (lprof == NULL) { LCONSOLE_ERROR_MSG(0x156, "The client profile '%s' could not be" @@ -1031,7 +958,7 @@ void ll_put_super(struct super_block *sb) LCONSOLE_WARN("client %s umount complete\n", ll_instance); - cfs_module_put(); + cfs_module_put(THIS_MODULE); EXIT; } /* client_put_super */ @@ -1117,7 +1044,7 @@ void ll_clear_inode(struct inode *inode) } #ifdef CONFIG_FS_POSIX_ACL else if (lli->lli_posix_acl) { - LASSERT(atomic_read(&lli->lli_posix_acl->a_refcount) == 1); + LASSERT(cfs_atomic_read(&lli->lli_posix_acl->a_refcount) == 1); LASSERT(lli->lli_remote_perms == NULL); posix_acl_release(lli->lli_posix_acl); lli->lli_posix_acl = NULL; @@ -1125,11 +1052,6 @@ void ll_clear_inode(struct inode *inode) #endif lli->lli_inode_magic = LLI_INODE_DEAD; -#ifdef HAVE_EXPORT___IGET - spin_lock(&sbi->ll_deathrow_lock); - list_del_init(&lli->lli_dead_list); - spin_unlock(&sbi->ll_deathrow_lock); -#endif ll_clear_inode_capas(inode); /* * XXX This has to be done before lsm is freed below, because @@ -1217,13 +1139,15 @@ static int ll_setattr_done_writing(struct inode *inode, CDEBUG(D_INODE, "Epoch "LPU64" closed on "DFID" for truncate\n", op_data->op_ioepoch, PFID(&lli->lli_fid)); - op_data->op_flags = MF_EPOCH_CLOSE | MF_SOM_CHANGE; + op_data->op_flags = MF_EPOCH_CLOSE; + ll_done_writing_attr(inode, op_data); + ll_pack_inode2opdata(inode, op_data, NULL); + rc = md_done_writing(ll_i2sbi(inode)->ll_md_exp, op_data, mod); if (rc == -EAGAIN) { /* MDS has instructed us to obtain Size-on-MDS attribute * from OSTs and send setattr to back to MDS. */ - rc = ll_sizeonmds_update(inode, &op_data->op_handle, - op_data->op_ioepoch); + rc = ll_som_update(inode, op_data); } else if (rc) { CERROR("inode %lu mdc truncate failed: rc = %d\n", inode->i_ino, rc); @@ -1231,23 +1155,22 @@ static int ll_setattr_done_writing(struct inode *inode, RETURN(rc); } -static int ll_setattr_do_truncate(struct inode *inode, loff_t size) +static int ll_setattr_ost(struct inode *inode, struct iattr *attr) { - struct obd_capa *capa = ll_osscapa_get(inode, CAPA_OPC_OSS_TRUNC); + struct obd_capa *capa; int rc; - rc = cl_setattr_do_truncate(inode, size, capa); - ll_truncate_free_capa(capa); - return rc; -} + if (attr->ia_valid & ATTR_SIZE) + capa = ll_osscapa_get(inode, CAPA_OPC_OSS_TRUNC); + else + capa = ll_mdscapa_get(inode); -static int ll_setattr_ost(struct inode *inode) -{ - struct obd_capa *capa = ll_mdscapa_get(inode); - int rc; + rc = cl_setattr_ost(inode, attr, capa); - rc = cl_setattr_ost(inode, capa); - capa_put(capa); + if (attr->ia_valid & ATTR_SIZE) + ll_truncate_free_capa(capa); + else + capa_put(capa); return rc; } @@ -1291,34 +1214,24 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr) /* POSIX: check before ATTR_*TIME_SET set (from inode_change_ok) */ if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) { - if (current->fsuid != inode->i_uid && + if (cfs_curproc_fsuid() != inode->i_uid && !cfs_capable(CFS_CAP_FOWNER)) RETURN(-EPERM); } /* We mark all of the fields "set" so MDS/OST does not re-set them */ if (attr->ia_valid & ATTR_CTIME) { - attr->ia_ctime = CURRENT_TIME; + attr->ia_ctime = CFS_CURRENT_TIME; attr->ia_valid |= ATTR_CTIME_SET; } if (!(ia_valid & ATTR_ATIME_SET) && (attr->ia_valid & ATTR_ATIME)) { - attr->ia_atime = CURRENT_TIME; + attr->ia_atime = CFS_CURRENT_TIME; attr->ia_valid |= ATTR_ATIME_SET; } if (!(ia_valid & ATTR_MTIME_SET) && (attr->ia_valid & ATTR_MTIME)) { - attr->ia_mtime = CURRENT_TIME; + attr->ia_mtime = CFS_CURRENT_TIME; attr->ia_valid |= ATTR_MTIME_SET; } - if ((attr->ia_valid & ATTR_CTIME) && !(attr->ia_valid & ATTR_MTIME)) { - /* To avoid stale mtime on mds, obtain it from ost and send - to mds. */ - rc = cl_glimpse_size(inode); - if (rc) - RETURN(rc); - - attr->ia_valid |= ATTR_MTIME_SET | ATTR_MTIME; - attr->ia_mtime = inode->i_mtime; - } if (attr->ia_valid & (ATTR_MTIME | ATTR_CTIME)) CDEBUG(D_INODE, "setting mtime %lu, ctime %lu, now = %lu\n", @@ -1337,11 +1250,19 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr) if (op_data == NULL) RETURN(-ENOMEM); + UNLOCK_INODE_MUTEX(inode); + if (ia_valid & ATTR_SIZE) + UP_WRITE_I_ALLOC_SEM(inode); + cfs_down(&lli->lli_trunc_sem); + LOCK_INODE_MUTEX(inode); + if (ia_valid & ATTR_SIZE) + DOWN_WRITE_I_ALLOC_SEM(inode); + memcpy(&op_data->op_attr, attr, sizeof(*attr)); /* Open epoch for truncate. */ - if ((ll_i2mdexp(inode)->exp_connect_flags & OBD_CONNECT_SOM) && - (ia_valid & ATTR_SIZE)) + if (exp_connect_som(ll_i2mdexp(inode)) && + (ia_valid & (ATTR_SIZE | ATTR_MTIME | ATTR_MTIME_SET))) op_data->op_flags = MF_EPOCH_OPEN; rc = ll_md_setattr(inode, op_data, &mod); @@ -1355,12 +1276,17 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr) } if (ia_valid & ATTR_SIZE) - rc = ll_setattr_do_truncate(inode, attr->ia_size); - else if (ia_valid & (ATTR_MTIME | ATTR_MTIME_SET)) { - CDEBUG(D_INODE, "set mtime on OST inode %lu to %lu\n", - inode->i_ino, LTIME_S(attr->ia_mtime)); - rc = ll_setattr_ost(inode); - } + attr->ia_valid |= ATTR_SIZE; + if ((ia_valid & ATTR_SIZE) || + (ia_valid | ATTR_ATIME | ATTR_ATIME_SET) || + (ia_valid | ATTR_MTIME | ATTR_MTIME_SET)) + /* on truncate and utimes send attributes to osts, setting + * mtime/atime to past will be performed under PW 0:EOF extent + * lock (new_size:EOF for truncate) + * it may seem excessive to send mtime/atime updates to osts + * when not setting times to past, but it is necessary due to + * possible time de-synchronization */ + rc = ll_setattr_ost(inode, attr); EXIT; out: if (op_data) { @@ -1368,6 +1294,7 @@ out: rc1 = ll_setattr_done_writing(inode, op_data, mod); ll_finish_md_op_data(op_data); } + cfs_up(&lli->lli_trunc_sem); return rc ? rc : rc1; } @@ -1454,10 +1381,10 @@ int ll_statfs(struct dentry *de, struct kstatfs *sfs) CDEBUG(D_VFSTRACE, "VFS Op: at "LPU64" jiffies\n", get_jiffies_64()); ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_STAFS, 1); - /* For now we will always get up-to-date statfs values, but in the - * future we may allow some amount of caching on the client (e.g. - * from QOS or lprocfs updates). */ - rc = ll_statfs_internal(sb, &osfs, cfs_time_current_64() - 1, 0); + /* Some amount of caching on the client is allowed */ + rc = ll_statfs_internal(sb, &osfs, + cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS), + 0); if (rc) return rc; @@ -1491,7 +1418,7 @@ void ll_inode_size_lock(struct inode *inode, int lock_lsm) lli = ll_i2info(inode); LASSERT(lli->lli_size_sem_owner != current); - down(&lli->lli_size_sem); + cfs_down(&lli->lli_size_sem); LASSERT(lli->lli_size_sem_owner == NULL); lli->lli_size_sem_owner = current; lsm = lli->lli_smd; @@ -1514,24 +1441,7 @@ void ll_inode_size_unlock(struct inode *inode, int unlock_lsm) lov_stripe_unlock(lsm); LASSERT(lli->lli_size_sem_owner == current); lli->lli_size_sem_owner = NULL; - up(&lli->lli_size_sem); -} - -static void ll_replace_lsm(struct inode *inode, struct lov_stripe_md *lsm) -{ - struct ll_inode_info *lli = ll_i2info(inode); - - dump_lsm(D_INODE, lsm); - dump_lsm(D_INODE, lli->lli_smd); - LASSERTF(lsm->lsm_magic == LOV_MAGIC_JOIN, - "lsm must be joined lsm %p\n", lsm); - obd_free_memmd(ll_i2dtexp(inode), &lli->lli_smd); - CDEBUG(D_INODE, "replace lsm %p to lli_smd %p for inode %lu%u(%p)\n", - lsm, lli->lli_smd, inode->i_ino, inode->i_generation, inode); - lli->lli_smd = lsm; - lli->lli_maxbytes = lsm->lsm_maxbytes; - if (lli->lli_maxbytes > PAGE_CACHE_MAXBYTES) - lli->lli_maxbytes = PAGE_CACHE_MAXBYTES; + cfs_up(&lli->lli_size_sem); } void ll_update_inode(struct inode *inode, struct lustre_md *md) @@ -1543,40 +1453,38 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md) LASSERT ((lsm != NULL) == ((body->valid & OBD_MD_FLEASIZE) != 0)); if (lsm != NULL) { + cfs_down(&lli->lli_och_sem); if (lli->lli_smd == NULL) { if (lsm->lsm_magic != LOV_MAGIC_V1 && - lsm->lsm_magic != LOV_MAGIC_V3 && - lsm->lsm_magic != LOV_MAGIC_JOIN) { + lsm->lsm_magic != LOV_MAGIC_V3) { dump_lsm(D_ERROR, lsm); LBUG(); } CDEBUG(D_INODE, "adding lsm %p to inode %lu/%u(%p)\n", lsm, inode->i_ino, inode->i_generation, inode); + /* cl_inode_init must go before lli_smd or a race is + * possible where client thinks the file has stripes, + * but lov raid0 is not setup yet and parallel e.g. + * glimpse would try to use uninitialized lov */ cl_inode_init(inode, md); - /* ll_inode_size_lock() requires it is only - * called with lli_smd != NULL or lock_lsm == 0 - * or we can race between lock/unlock. - * bug 9547 */ lli->lli_smd = lsm; + cfs_up(&lli->lli_och_sem); lli->lli_maxbytes = lsm->lsm_maxbytes; if (lli->lli_maxbytes > PAGE_CACHE_MAXBYTES) lli->lli_maxbytes = PAGE_CACHE_MAXBYTES; } else { - if (lli->lli_smd->lsm_magic == lsm->lsm_magic && - lli->lli_smd->lsm_stripe_count == - lsm->lsm_stripe_count) { - if (lov_stripe_md_cmp(lli->lli_smd, lsm)) { - CERROR("lsm mismatch for inode %ld\n", - inode->i_ino); - CERROR("lli_smd:\n"); - dump_lsm(D_ERROR, lli->lli_smd); - CERROR("lsm:\n"); - dump_lsm(D_ERROR, lsm); - LBUG(); - } - } else { - cl_inode_init(inode, md); - ll_replace_lsm(inode, lsm); + cfs_up(&lli->lli_och_sem); + LASSERT(lli->lli_smd->lsm_magic == lsm->lsm_magic && + lli->lli_smd->lsm_stripe_count == + lsm->lsm_stripe_count); + if (lov_stripe_md_cmp(lli->lli_smd, lsm)) { + CERROR("lsm mismatch for inode %ld\n", + inode->i_ino); + CERROR("lli_smd:\n"); + dump_lsm(D_ERROR, lli->lli_smd); + CERROR("lsm:\n"); + dump_lsm(D_ERROR, lsm); + LBUG(); } } if (lli->lli_smd != lsm) @@ -1589,33 +1497,34 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md) } #ifdef CONFIG_FS_POSIX_ACL else if (body->valid & OBD_MD_FLACL) { - spin_lock(&lli->lli_lock); + cfs_spin_lock(&lli->lli_lock); if (lli->lli_posix_acl) posix_acl_release(lli->lli_posix_acl); lli->lli_posix_acl = md->posix_acl; - spin_unlock(&lli->lli_lock); + cfs_spin_unlock(&lli->lli_lock); } #endif - inode->i_ino = ll_fid_build_ino(sbi, &body->fid1); - inode->i_generation = ll_fid_build_gen(sbi, &body->fid1); - - if (body->valid & OBD_MD_FLATIME && - body->atime > LTIME_S(inode->i_atime)) - LTIME_S(inode->i_atime) = body->atime; - - /* mtime is always updated with ctime, but can be set in past. - As write and utime(2) may happen within 1 second, and utime's - mtime has a priority over write's one, so take mtime from mds - for the same ctimes. */ - if (body->valid & OBD_MD_FLCTIME && - body->ctime >= LTIME_S(inode->i_ctime)) { - LTIME_S(inode->i_ctime) = body->ctime; - if (body->valid & OBD_MD_FLMTIME) { - CDEBUG(D_INODE, "setting ino %lu mtime " - "from %lu to "LPU64"\n", inode->i_ino, + inode->i_ino = cl_fid_build_ino(&body->fid1); + inode->i_generation = cl_fid_build_gen(&body->fid1); + + if (body->valid & OBD_MD_FLATIME) { + if (body->atime > LTIME_S(inode->i_atime)) + LTIME_S(inode->i_atime) = body->atime; + lli->lli_lvb.lvb_atime = body->atime; + } + if (body->valid & OBD_MD_FLMTIME) { + if (body->mtime > LTIME_S(inode->i_mtime)) { + CDEBUG(D_INODE, "setting ino %lu mtime from %lu " + "to "LPU64"\n", inode->i_ino, LTIME_S(inode->i_mtime), body->mtime); LTIME_S(inode->i_mtime) = body->mtime; } + lli->lli_lvb.lvb_mtime = body->mtime; + } + if (body->valid & OBD_MD_FLCTIME) { + if (body->ctime > LTIME_S(inode->i_ctime)) + LTIME_S(inode->i_ctime) = body->ctime; + lli->lli_lvb.lvb_ctime = body->ctime; } if (body->valid & OBD_MD_FLMODE) inode->i_mode = (inode->i_mode & S_IFMT)|(body->mode & ~S_IFMT); @@ -1687,6 +1596,9 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md) /* Use old size assignment to avoid * deadlock bz14138 & bz14326 */ inode->i_size = body->size; + + CDEBUG(D_VFSTRACE, "inode=%lu, updating i_size %llu\n", + inode->i_ino, (unsigned long long)body->size); } if (body->valid & OBD_MD_FLBLOCKS) @@ -1791,12 +1703,17 @@ int ll_iocontrol(struct inode *inode, struct file *file, switch(cmd) { case FSFILT_IOC_GETFLAGS: { struct mdt_body *body; - struct obd_capa *oc; + struct md_op_data *op_data; - oc = ll_mdscapa_get(inode); - rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode), oc, - OBD_MD_FLFLAGS, 0, &req); - capa_put(oc); + op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, + 0, 0, LUSTRE_OPC_ANY, + NULL); + if (op_data == NULL) + RETURN(-ENOMEM); + + op_data->op_valid = OBD_MD_FLFLAGS; + rc = md_getattr(sbi->ll_md_exp, op_data, &req); + ll_finish_md_op_data(op_data); if (rc) { CERROR("failure %d inode %lu\n", rc, inode->i_ino); RETURN(-abs(rc)); @@ -1845,14 +1762,13 @@ int ll_iocontrol(struct inode *inode, struct file *file, } oinfo.oi_oa->o_id = lsm->lsm_object_id; - oinfo.oi_oa->o_gr = lsm->lsm_object_gr; + oinfo.oi_oa->o_seq = lsm->lsm_object_seq; oinfo.oi_oa->o_flags = flags; oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP; oinfo.oi_capa = ll_mdscapa_get(inode); - obdo_from_inode(oinfo.oi_oa, inode, - OBD_MD_FLFID | OBD_MD_FLGENER); + &ll_i2info(inode)->lli_fid, 0); rc = obd_setattr_rqset(sbi->ll_dt_exp, &oinfo, NULL); capa_put(oinfo.oi_capa); OBDO_FREE(oinfo.oi_oa); @@ -1864,8 +1780,7 @@ int ll_iocontrol(struct inode *inode, struct file *file, EXIT; update_cache: - inode->i_flags = ll_ext_to_inode_flags(flags | - MDS_BFLAG_EXT_FLAGS); + inode->i_flags = ll_ext_to_inode_flags(flags); return 0; } default: @@ -1879,7 +1794,7 @@ int ll_flush_ctx(struct inode *inode) { struct ll_sb_info *sbi = ll_i2sbi(inode); - CDEBUG(D_SEC, "flush context for user %d\n", current->uid); + CDEBUG(D_SEC, "flush context for user %d\n", cfs_curproc_uid()); obd_set_info_async(sbi->ll_md_exp, sizeof(KEY_FLUSH_CTX), KEY_FLUSH_CTX, @@ -1902,7 +1817,7 @@ void ll_umount_begin(struct super_block *sb) struct lustre_sb_info *lsi = s2lsi(sb); struct ll_sb_info *sbi = ll_s2sbi(sb); struct obd_device *obd; - struct obd_ioctl_data ioc_data = { 0 }; + struct obd_ioctl_data *ioc_data; ENTRY; #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT @@ -1926,8 +1841,6 @@ void ll_umount_begin(struct super_block *sb) return; } obd->obd_force = 1; - obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_md_exp, sizeof ioc_data, - &ioc_data, NULL); obd = class_exp2obd(sbi->ll_dt_exp); if (obd == NULL) { @@ -1936,20 +1849,29 @@ void ll_umount_begin(struct super_block *sb) EXIT; return; } - obd->obd_force = 1; - obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_dt_exp, sizeof ioc_data, - &ioc_data, NULL); + + OBD_ALLOC_PTR(ioc_data); + if (ioc_data) { + obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_md_exp, + sizeof ioc_data, ioc_data, NULL); + + obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_dt_exp, + sizeof ioc_data, ioc_data, NULL); + + OBD_FREE_PTR(ioc_data); + } + /* Really, we'd like to wait until there are no requests outstanding, * and then continue. For now, we just invalidate the requests, * schedule() and sleep one second if needed, and hope. */ - schedule(); + cfs_schedule(); #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT if (atomic_read(&vfsmnt->mnt_count) > 2) { - cfs_schedule_timeout(CFS_TASK_INTERRUPTIBLE, - cfs_time_seconds(1)); + cfs_schedule_timeout_and_set_state(CFS_TASK_INTERRUPTIBLE, + cfs_time_seconds(1)); if (atomic_read(&vfsmnt->mnt_count) > 2) LCONSOLE_WARN("Mount still busy with %d refs! You " "may try to umount it a bit later\n", @@ -1997,7 +1919,6 @@ int ll_prep_inode(struct inode **inode, LASSERT(*inode || sb); sbi = sb ? ll_s2sbi(sb) : ll_i2sbi(*inode); - prune_deathrow(sbi, 1); memset(&md, 0, sizeof(struct lustre_md)); rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp, @@ -2016,7 +1937,7 @@ int ll_prep_inode(struct inode **inode, */ LASSERT(fid_is_sane(&md.body->fid1)); - *inode = ll_iget(sb, ll_fid_build_ino(sbi, &md.body->fid1),&md); + *inode = ll_iget(sb, cl_fid_build_ino(&md.body->fid1), &md); if (*inode == NULL || IS_ERR(*inode)) { if (md.lsm) obd_free_memmd(sbi->ll_dt_exp, &md.lsm); @@ -2033,8 +1954,6 @@ int ll_prep_inode(struct inode **inode, } } - rc = obd_checkmd(sbi->ll_dt_exp, sbi->ll_md_exp, - ll_i2info(*inode)->lli_smd); out: md_free_lustre_md(sbi->ll_md_exp, &md); RETURN(rc); @@ -2061,6 +1980,12 @@ int ll_obd_statfs(struct inode *inode, void *arg) !data->ioc_pbuf1 || !data->ioc_pbuf2) GOTO(out_statfs, rc = -EINVAL); + if (data->ioc_inllen1 != sizeof(__u32) || + data->ioc_inllen2 != sizeof(__u32) || + data->ioc_plen1 != sizeof(struct obd_statfs) || + data->ioc_plen2 != sizeof(struct obd_uuid)) + GOTO(out_statfs, rc = -EINVAL); + memcpy(&type, data->ioc_inlbuf1, sizeof(__u32)); if (type == LL_STATFS_MDC) exp = sbi->ll_md_exp; @@ -2140,8 +2065,8 @@ struct md_op_data * ll_prep_md_op_data(struct md_op_data *op_data, op_data->op_namelen = namelen; op_data->op_mode = mode; op_data->op_mod_time = cfs_time_current_sec(); - op_data->op_fsuid = current->fsuid; - op_data->op_fsgid = current->fsgid; + op_data->op_fsuid = cfs_curproc_fsuid(); + op_data->op_fsgid = cfs_curproc_fsgid(); op_data->op_cap = cfs_curproc_cap_pack(); op_data->op_bias = MDS_CHECK_SPLIT; op_data->op_opc = opc; @@ -2177,11 +2102,21 @@ int ll_show_options(struct seq_file *seq, struct vfsmount *vfs) if (sbi->ll_flags & LL_SBI_USER_XATTR) seq_puts(seq, ",user_xattr"); - if (sbi->ll_flags & LL_SBI_ACL) - seq_puts(seq, ",acl"); - if (sbi->ll_flags & LL_SBI_LAZYSTATFS) seq_puts(seq, ",lazystatfs"); RETURN(0); } + +int ll_sync_fs(struct super_block *sb, int wait) +{ + struct ll_sb_info *sbi = ll_s2sbi(sb); + int rc = 0; + ENTRY; + + rc = obd_sync_fs(class_exp2obd(sbi->ll_dt_exp), NULL, wait); + if (rc) + CERROR("sync_fs fails: rc = %d\n", rc); + + RETURN(rc); +}