X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fllite_capa.c;h=adf956012436afd983a766e47e5a2fcbbfa1f0ec;hb=e4deafd378448a0ef27ec4c2d1c191cc55bf691c;hp=aeb7a3201f1a626d9d595e0cc5768a5598421198;hpb=19b56648cba265c45c7202ee103175b96c0b6820;p=fs%2Flustre-release.git diff --git a/lustre/llite/llite_capa.c b/lustre/llite/llite_capa.c index aeb7a32..adf9560 100644 --- a/lustre/llite/llite_capa.c +++ b/lustre/llite/llite_capa.c @@ -1,7 +1,7 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (C) 2004, 2005 Cluster File Systems, Inc. + * Copyright (C) 2005 Cluster File Systems, Inc. * * Author: Lai Siyao * @@ -29,169 +29,244 @@ #include #include -#include +#include #include "llite_internal.h" -static struct list_head *ll_capa_list = &capa_list[CLIENT_CAPA]; -static struct ptlrpc_thread capa_thread; +/* for obd_capa.c_list, client capa might stay in three places: + * 1. ll_capa_list. + * 2. ll_idle_capas. + * 3. stand alone: just allocated. + */ + +/* capas for oss writeback and those failed to renew */ +static LIST_HEAD(ll_idle_capas); +static struct ptlrpc_thread ll_capa_thread; +static struct list_head *ll_capa_list = &capa_list[CAPA_SITE_CLIENT]; + +/* llite capa renewal timer */ +struct timer_list ll_capa_timer; +/* for debug: indicate whether capa on llite is enabled or not */ +static atomic_t ll_capa_debug = ATOMIC_INIT(0); +static unsigned long long ll_capa_renewed = 0; +static unsigned long long ll_capa_renewal_noent = 0; +static unsigned long long ll_capa_renewal_failed = 0; +static unsigned long long ll_capa_renewal_retries = 0; + +static inline void update_capa_timer(struct obd_capa *ocapa, cfs_time_t expiry) +{ + if (time_before(expiry, ll_capa_timer.expires) || + !timer_pending(&ll_capa_timer)) { + mod_timer(&ll_capa_timer, expiry); + DEBUG_CAPA(D_SEC, &ocapa->c_capa, + "ll_capa_timer update: %lu/%lu by", expiry, jiffies); + } +} + +static inline cfs_time_t capa_renewal_time(struct obd_capa *ocapa) +{ + return cfs_time_sub(ocapa->c_expiry, + cfs_time_seconds(ocapa->c_capa.lc_timeout) / 2); +} -static struct thread_ctl { - struct completion ctl_starting; - struct completion ctl_finishing; -} ll_capa_ctl; +static inline int capa_is_to_expire(struct obd_capa *ocapa) +{ + return cfs_time_beforeq(capa_renewal_time(ocapa), cfs_time_current()); +} static inline int have_expired_capa(void) { - struct obd_capa *ocapa; - struct lustre_capa *capa; + struct obd_capa *ocapa = NULL; int expired = 0; - unsigned long expiry; - ENTRY; + /* if ll_capa_list has client capa to expire or ll_idle_capas has + * expired capa, return 1. + */ spin_lock(&capa_lock); if (!list_empty(ll_capa_list)) { ocapa = list_entry(ll_capa_list->next, struct obd_capa, c_list); - expired = __capa_is_to_expire(ocapa); - if (!expired) { - capa = &ocapa->c_capa; - expiry = expiry_to_jiffies(capa->lc_expiry - - capa_pre_expiry(capa)); - if (time_before(expiry, ll_capa_timer.expires) || - !timer_pending(&ll_capa_timer)) { - mod_timer(&ll_capa_timer, expiry); - CDEBUG(D_INFO,"ll_capa_timer new expiry: %lu\n", - expiry); - } - } + expired = capa_is_to_expire(ocapa); + if (!expired) + update_capa_timer(ocapa, capa_renewal_time(ocapa)); + } else if (!list_empty(&ll_idle_capas)) { + ocapa = list_entry(ll_idle_capas.next, struct obd_capa, c_list); + expired = capa_is_expired(ocapa); + if (!expired) + update_capa_timer(ocapa, ocapa->c_expiry); } spin_unlock(&capa_lock); - RETURN(expired); + if (expired) + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "expired"); + return expired; } -static int inline ll_capa_check_stop(void) +static inline int ll_capa_check_stop(void) { - return (capa_thread.t_flags & SVC_STOPPING) ? 1: 0; + return (ll_capa_thread.t_flags & SVC_STOPPING) ? 1: 0; } -static int ll_renew_capa(struct obd_capa *ocapa) +static void sort_add_capa(struct obd_capa *ocapa, struct list_head *head) { - struct ptlrpc_request *req = NULL; - /* no need to lock, no one else will touch it */ - struct inode *inode = ocapa->c_inode; - struct obd_export *md_exp = ll_i2mdexp(inode); - struct ll_inode_info *lli = ll_i2info(inode); - __u64 valid = OBD_MD_CAPA; - int rc; - ENTRY; + struct obd_capa *tmp; + struct list_head *before = NULL; + + /* TODO: client capa is sorted by expiry, this could be optimized */ + list_for_each_entry_reverse(tmp, head, c_list) { + if (cfs_time_aftereq(ocapa->c_expiry, tmp->c_expiry)) { + before = &tmp->c_list; + break; + } + } - if (capa_expired(&ocapa->c_capa)) - RETURN(-ESTALE); + LASSERT(&ocapa->c_list != before); + list_add(&ocapa->c_list, before ?: head); +} - rc = md_getattr(md_exp, &lli->lli_id, valid, NULL, NULL, 0, - 0, ocapa, &req); - RETURN(rc); +static inline int obd_capa_open_count(struct obd_capa *oc) +{ + struct ll_inode_info *lli = ll_i2info(oc->u.cli.inode); + return atomic_read(&lli->lli_open_count); } -static int ll_capa_thread(void *arg) +static void ll_delete_capa(struct obd_capa *ocapa) { - struct thread_ctl *ctl = arg; - unsigned long flags; - int rc; - ENTRY; + struct ll_inode_info *lli = ll_i2info(ocapa->u.cli.inode); - { - char name[sizeof(current->comm)]; - snprintf(name, sizeof(name) - 1, "ll_capa"); - kportal_daemonize(name); + if (capa_for_mds(&ocapa->c_capa)) { + LASSERT(lli->lli_mds_capa == ocapa); + lli->lli_mds_capa = NULL; + } else if (capa_for_oss(&ocapa->c_capa)) { + list_del_init(&ocapa->u.cli.lli_list); } - SIGNAL_MASK_LOCK(current, flags); - sigfillset(¤t->blocked); - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "free client"); + list_del(&ocapa->c_list); + capa_count[CAPA_SITE_CLIENT]--; + free_capa(ocapa); +} - /* - * letting starting function know, that we are ready and control may be - * returned. - */ - capa_thread.t_flags = SVC_RUNNING; - complete(&ctl->ctl_starting); +/* three places where client capa is deleted: + * 1. capa_thread_main(), main place to delete expired capa. + * 2. ll_clear_inode_capas() in ll_clear_inode(). + * 3. ll_truncate_free_capa() delete truncate capa explicitly in ll_truncate(). + */ +static int capa_thread_main(void *unused) +{ + struct obd_capa *ocapa, *tmp, *next; + struct inode *inode = NULL; + struct l_wait_info lwi = { 0 }; + int rc; + ENTRY; - while (1) { - struct l_wait_info lwi = { 0 }; - struct obd_capa *ocapa, tcapa, *tmp, *next = NULL; - unsigned long expiry, sleep = CAPA_PRE_EXPIRY; - struct inode *inode; + cfs_daemonize("ll_capa"); - l_wait_event(capa_thread.t_ctl_waitq, - (have_expired_capa() || ll_capa_check_stop()), + ll_capa_thread.t_flags = SVC_RUNNING; + wake_up(&ll_capa_thread.t_ctl_waitq); + + while (1) { + l_wait_event(ll_capa_thread.t_ctl_waitq, + (ll_capa_check_stop() || have_expired_capa()), &lwi); if (ll_capa_check_stop()) break; + next = NULL; + spin_lock(&capa_lock); list_for_each_entry_safe(ocapa, tmp, ll_capa_list, c_list) { - if (ocapa->c_capa.lc_flags & CAPA_FL_SHORT) - sleep = CAPA_PRE_EXPIRY_SHORT; + LASSERT(ocapa->c_capa.lc_opc != CAPA_OPC_OSS_TRUNC); - if (ocapa->c_capa.lc_op == CAPA_TRUNC) + if (!capa_is_to_expire(ocapa)) { + next = ocapa; + break; + } + + list_del_init(&ocapa->c_list); + + /* for MDS capability, only renew those which belong to + * dir, or its inode is opened, or client holds LOOKUP + * lock. + */ + if (capa_for_mds(&ocapa->c_capa) && + !S_ISDIR(ocapa->u.cli.inode->i_mode) && + obd_capa_open_count(ocapa) == 0 && + !ll_have_md_lock(ocapa->u.cli.inode, + MDS_INODELOCK_LOOKUP)) { + DEBUG_CAPA(D_SEC, &ocapa->c_capa, + "skip renewal for"); + sort_add_capa(ocapa, &ll_idle_capas); continue; + } - if (__capa_is_to_expire(ocapa)) { - inode = igrab(ocapa->c_inode); - if (inode == NULL) - continue; + /* for OSS capability, only renew those whose inode is + * opened. + */ + if (capa_for_oss(&ocapa->c_capa) && + obd_capa_open_count(ocapa) == 0) { + /* oss capa with open count == 0 won't renew, + * move to idle list */ + sort_add_capa(ocapa, &ll_idle_capas); + continue; + } - tcapa = *ocapa; - spin_unlock(&capa_lock); + /* NB iput() is in ll_update_capa() */ + inode = igrab(ocapa->u.cli.inode); + if (inode == NULL) { + DEBUG_CAPA(D_ERROR, &ocapa->c_capa, + "igrab failed for"); + continue; + } - rc = ll_renew_capa(&tcapa); - iput(inode); + capa_get(ocapa); + ll_capa_renewed++; + spin_unlock(&capa_lock); + + rc = md_renew_capa(ll_i2mdexp(inode), ocapa, + ll_update_capa); + spin_lock(&capa_lock); + if (rc) { + DEBUG_CAPA(D_ERROR, &ocapa->c_capa, + "renew failed: %d", rc); + ll_capa_renewal_failed++; + } + } - if (rc) - capa_put(ocapa); + if (next) + update_capa_timer(next, capa_renewal_time(next)); - spin_lock(&capa_lock); - } else { - next = ocapa; + list_for_each_entry_safe(ocapa, tmp, &ll_idle_capas, c_list) { + if (!capa_is_expired(ocapa)) { + if (!next) + update_capa_timer(ocapa, ocapa->c_expiry); break; } - } - if (next) { - struct lustre_capa *capa = &next->c_capa; - - expiry = expiry_to_jiffies(capa->lc_expiry - - capa_pre_expiry(capa)); - if (time_before(expiry, ll_capa_timer.expires) || - !timer_pending(&ll_capa_timer)) { - mod_timer(&ll_capa_timer, expiry); - CDEBUG(D_INFO,"ll_capa_timer new expiry: %lu\n", - expiry); + if (atomic_read(&ocapa->c_refc)) { + DEBUG_CAPA(D_SEC, &ocapa->c_capa, + "expired(c_refc %d), don't release", + atomic_read(&ocapa->c_refc)); + /* don't try to renew any more */ + list_del_init(&ocapa->c_list); + continue; } + + /* expired capa is released. */ + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "release expired"); + ll_delete_capa(ocapa); } - spin_unlock(&capa_lock); - /* wait ll_renew_capa finish */ - set_current_state(TASK_INTERRUPTIBLE); - schedule_timeout(sleep * HZ); + spin_unlock(&capa_lock); } - capa_thread.t_flags = SVC_STOPPED; - - /* this is SMP-safe way to finish thread. */ - complete_and_exit(&ctl->ctl_finishing, 0); - EXIT; + ll_capa_thread.t_flags = SVC_STOPPED; + wake_up(&ll_capa_thread.t_ctl_waitq); + RETURN(0); } -/* just wake up, others are handled by ll_capa_thread */ void ll_capa_timer_callback(unsigned long unused) { - ENTRY; - wake_up(&capa_thread.t_ctl_waitq); - EXIT; + wake_up(&ll_capa_thread.t_ctl_waitq); } int ll_capa_thread_start(void) @@ -199,141 +274,359 @@ int ll_capa_thread_start(void) int rc; ENTRY; - LASSERT(capa_thread.t_flags == 0); - init_completion(&ll_capa_ctl.ctl_starting); - init_completion(&ll_capa_ctl.ctl_finishing); - init_waitqueue_head(&capa_thread.t_ctl_waitq); + init_waitqueue_head(&ll_capa_thread.t_ctl_waitq); - rc = kernel_thread(ll_capa_thread, &ll_capa_ctl, - (CLONE_VM | CLONE_FILES)); + rc = kernel_thread(capa_thread_main, NULL, 0); if (rc < 0) { - CERROR("cannot start expired capa thread, " - "err = %d\n", rc); + CERROR("cannot start expired capa thread: rc %d\n", rc); RETURN(rc); } - wait_for_completion(&ll_capa_ctl.ctl_starting); - LASSERT(capa_thread.t_flags == SVC_RUNNING); + wait_event(ll_capa_thread.t_ctl_waitq, + ll_capa_thread.t_flags & SVC_RUNNING); + RETURN(0); } void ll_capa_thread_stop(void) { + ll_capa_thread.t_flags = SVC_STOPPING; + wake_up(&ll_capa_thread.t_ctl_waitq); + wait_event(ll_capa_thread.t_ctl_waitq, + ll_capa_thread.t_flags & SVC_STOPPED); +} + +static struct obd_capa *do_lookup_oss_capa(struct inode *inode, int opc) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct obd_capa *ocapa; + + /* inside capa_lock */ + list_for_each_entry(ocapa, &lli->lli_oss_capas, u.cli.lli_list) { + if ((capa_opc(&ocapa->c_capa) & opc) != opc) + continue; + + LASSERT(lu_fid_eq(capa_fid(&ocapa->c_capa), + ll_inode2fid(inode))); + LASSERT(ocapa->c_site == CAPA_SITE_CLIENT); + + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "found client"); + return ocapa; + } + + return NULL; +} + +struct obd_capa *ll_osscapa_get(struct inode *inode, __u64 opc) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct obd_capa *ocapa; + int found = 0; + + if ((ll_i2sbi(inode)->ll_flags & LL_SBI_OSS_CAPA) == 0) + return NULL; ENTRY; - capa_thread.t_flags = SVC_STOPPING; - wake_up(&capa_thread.t_ctl_waitq); - wait_for_completion(&ll_capa_ctl.ctl_finishing); - LASSERT(capa_thread.t_flags == SVC_STOPPED); - capa_thread.t_flags = 0; + LASSERT(opc == CAPA_OPC_OSS_WRITE || opc == CAPA_OPC_OSS_RW || + opc == CAPA_OPC_OSS_TRUNC); - EXIT; + spin_lock(&capa_lock); + list_for_each_entry(ocapa, &lli->lli_oss_capas, u.cli.lli_list) { + if (capa_is_expired(ocapa)) + continue; + if ((opc & CAPA_OPC_OSS_WRITE) && + capa_opc_supported(&ocapa->c_capa, CAPA_OPC_OSS_WRITE)) { + found = 1; break; + } else if ((opc & CAPA_OPC_OSS_READ) && + capa_opc_supported(&ocapa->c_capa, + CAPA_OPC_OSS_READ)) { + found = 1; break; + } else if ((opc & CAPA_OPC_OSS_TRUNC) && + capa_opc_supported(&ocapa->c_capa, opc)) { + found = 1; break; + } + } + + if (found) { + LASSERT(lu_fid_eq(capa_fid(&ocapa->c_capa), + ll_inode2fid(inode))); + LASSERT(ocapa->c_site == CAPA_SITE_CLIENT); + + capa_get(ocapa); + + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "found client"); + } else { + ocapa = NULL; + + if (atomic_read(&ll_capa_debug)) { + CERROR("no capability for "DFID" opc "LPX64"\n", + PFID(&lli->lli_fid), opc); + atomic_set(&ll_capa_debug, 0); + } + } + spin_unlock(&capa_lock); + + RETURN(ocapa); } +EXPORT_SYMBOL(ll_osscapa_get); -int ll_set_capa(struct inode *inode, struct lookup_intent *it, - struct obd_client_handle *och) +struct obd_capa *ll_mdscapa_get(struct inode *inode) { - struct ptlrpc_request *req = LUSTRE_IT(it)->it_data; - struct mds_body *body; - struct lustre_capa *capa; + struct ll_inode_info *lli = ll_i2info(inode); struct obd_capa *ocapa; + ENTRY; + + LASSERT(inode != NULL); + + if ((ll_i2sbi(inode)->ll_flags & LL_SBI_MDS_CAPA) == 0) + RETURN(NULL); + + spin_lock(&capa_lock); + ocapa = capa_get(lli->lli_mds_capa); + spin_unlock(&capa_lock); + if (!ocapa && atomic_read(&ll_capa_debug)) { + CERROR("no mds capability for "DFID"\n", PFID(&lli->lli_fid)); + atomic_set(&ll_capa_debug, 0); + } + + RETURN(ocapa); +} + +static struct obd_capa *do_add_mds_capa(struct inode *inode, + struct obd_capa *ocapa) +{ struct ll_inode_info *lli = ll_i2info(inode); - unsigned long expiry; + struct obd_capa *old = lli->lli_mds_capa; + struct lustre_capa *capa = &ocapa->c_capa; - if (!S_ISREG(inode->i_mode)) - return 0; + if (!old) { + ocapa->u.cli.inode = inode; + lli->lli_mds_capa = ocapa; + capa_count[CAPA_SITE_CLIENT]++; - /* GNS code path will have no req */ - if (!req) - return 0; + DEBUG_CAPA(D_SEC, capa, "add MDS"); + } else { + spin_lock(&old->c_lock); + old->c_capa = *capa; + spin_unlock(&old->c_lock); - body = lustre_msg_buf(req->rq_repmsg, 1, sizeof (*body)); - LASSERT(body != NULL); /* reply already checked out */ - LASSERT_REPSWABBED(req, 1); /* and swabbed down */ + DEBUG_CAPA(D_SEC, capa, "update MDS"); - if (!(body->valid & OBD_MD_CAPA)) - return 0; + free_capa(ocapa); + ocapa = old; + } + return ocapa; +} - ENTRY; +static inline void inode_add_oss_capa(struct inode *inode, + struct obd_capa *ocapa) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct obd_capa *tmp; + struct list_head *next = NULL; + + /* capa is sorted in lli_oss_capas so lookup can always find the + * latest one */ + list_for_each_entry(tmp, &lli->lli_oss_capas, u.cli.lli_list) { + if (cfs_time_after(ocapa->c_expiry, tmp->c_expiry)) { + next = &tmp->u.cli.lli_list; + break; + } + } + LASSERT(&ocapa->u.cli.lli_list != next); + list_move_tail(&ocapa->u.cli.lli_list, next ?: &lli->lli_oss_capas); +} - capa = lustre_msg_buf(req->rq_repmsg, 7, sizeof (*capa)); - LASSERT(capa != NULL); /* reply already checked out */ - LASSERT_REPSWABBED(req, 7); /* and swabbed down */ +static struct obd_capa *do_add_oss_capa(struct inode *inode, + struct obd_capa *ocapa) +{ + struct obd_capa *old; + struct lustre_capa *capa = &ocapa->c_capa; + + LASSERTF(S_ISREG(inode->i_mode), + "inode has oss capa, but not regular file, mode: %d\n", + inode->i_mode); + + /* FIXME: can't replace it so easily with fine-grained opc */ + old = do_lookup_oss_capa(inode, capa_opc(capa) & CAPA_OPC_OSS_ONLY); + if (!old) { + ocapa->u.cli.inode = inode; + INIT_LIST_HEAD(&ocapa->u.cli.lli_list); + capa_count[CAPA_SITE_CLIENT]++; + + DEBUG_CAPA(D_SEC, capa, "add OSS"); + } else { + spin_lock(&old->c_lock); + old->c_capa = *capa; + spin_unlock(&old->c_lock); + + DEBUG_CAPA(D_SEC, capa, "update OSS"); + + free_capa(ocapa); + ocapa = old; + } - ocapa = capa_renew(capa, CLIENT_CAPA); - if (!ocapa) - RETURN(-ENOMEM); + inode_add_oss_capa(inode, ocapa); + return ocapa; +} +struct obd_capa *ll_add_capa(struct inode *inode, struct obd_capa *ocapa) +{ spin_lock(&capa_lock); - ocapa->c_inode = inode; - ocapa->c_handle = och->och_fh; + ocapa = capa_for_mds(&ocapa->c_capa) ? do_add_mds_capa(inode, ocapa) : + do_add_oss_capa(inode, ocapa); + + /* truncate capa won't renew */ + if (ocapa->c_capa.lc_opc != CAPA_OPC_OSS_TRUNC) { + set_capa_expiry(ocapa); + list_del(&ocapa->c_list); + sort_add_capa(ocapa, ll_capa_list); + + update_capa_timer(ocapa, capa_renewal_time(ocapa)); + } + spin_unlock(&capa_lock); - spin_lock(&lli->lli_lock); - /* in case it was linked to lli_capas already */ - if (list_empty(&ocapa->c_lli_list)) - list_add(&ocapa->c_lli_list, &lli->lli_capas); - spin_unlock(&lli->lli_lock); + atomic_set(&ll_capa_debug, 1); + return ocapa; +} - expiry = expiry_to_jiffies(capa->lc_expiry - capa_pre_expiry(capa)); +static inline void delay_capa_renew(struct obd_capa *oc, cfs_time_t delay) +{ + /* NB: set a fake expiry for this capa to prevent it renew too soon */ + oc->c_expiry = cfs_time_add(oc->c_expiry, cfs_time_seconds(delay)); +} - spin_lock(&capa_lock); - if (time_before(expiry, ll_capa_timer.expires) || - !timer_pending(&ll_capa_timer)) { - mod_timer(&ll_capa_timer, expiry); - CDEBUG(D_INFO, "ll_capa_timer new expiry: %lu\n", expiry); +int ll_update_capa(struct obd_capa *ocapa, struct lustre_capa *capa) +{ + struct inode *inode = ocapa->u.cli.inode; + int rc = 0; + ENTRY; + + LASSERT(ocapa); + + if (IS_ERR(capa)) { + /* set error code */ + rc = PTR_ERR(capa); + spin_lock(&capa_lock); + if (rc == -ENOENT) { + DEBUG_CAPA(D_SEC, &ocapa->c_capa, + "renewal canceled because object removed"); + ll_capa_renewal_noent++; + } else { + ll_capa_renewal_failed++; + + /* failed capa won't be renewed any longer, but if -EIO, + * client might be doing recovery, retry in 2 min. */ + if (rc == -EIO && !capa_is_expired(ocapa)) { + delay_capa_renew(ocapa, 120); + DEBUG_CAPA(D_ERROR, &ocapa->c_capa, + "renewal failed: -EIO, retry in 2 mins"); + ll_capa_renewal_retries++; + GOTO(retry, rc); + } else { + DEBUG_CAPA(D_ERROR, &ocapa->c_capa, + "renewal failed(rc: %d) for", rc); + } + } + + list_del(&ocapa->c_list); + sort_add_capa(ocapa, &ll_idle_capas); + spin_unlock(&capa_lock); + + capa_put(ocapa); + iput(inode); + return rc; } + + spin_lock(&ocapa->c_lock); + LASSERT(!memcmp(&ocapa->c_capa, capa, + offsetof(struct lustre_capa, lc_flags))); + ocapa->c_capa = *capa; + set_capa_expiry(ocapa); + spin_unlock(&ocapa->c_lock); + + spin_lock(&capa_lock); + if (capa_for_oss(capa)) + inode_add_oss_capa(inode, ocapa); + DEBUG_CAPA(D_SEC, capa, "renew"); + EXIT; +retry: + list_del_init(&ocapa->c_list); + sort_add_capa(ocapa, ll_capa_list); + update_capa_timer(ocapa, capa_renewal_time(ocapa)); spin_unlock(&capa_lock); - RETURN(0); + capa_put(ocapa); + iput(inode); + return rc; } -int ll_set_trunc_capa(struct ptlrpc_request *req, int offset, struct inode *inode) +void ll_capa_open(struct inode *inode) { - struct mds_body *body; - struct obd_capa *ocapa; - struct lustre_capa *capa; struct ll_inode_info *lli = ll_i2info(inode); - body = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*body)); - if (!body) - return -ENOMEM; + if ((ll_i2sbi(inode)->ll_flags & (LL_SBI_MDS_CAPA | LL_SBI_OSS_CAPA)) + == 0) + return; - if (!(body->valid & OBD_MD_CAPA)) - return 0; + if (!S_ISREG(inode->i_mode)) + return; - ENTRY; - capa = (struct lustre_capa *)lustre_swab_repbuf(req, offset + 1, - sizeof(*capa), lustre_swab_lustre_capa); - if (!capa) - RETURN(-ENOMEM); + atomic_inc(&lli->lli_open_count); +} - ocapa = capa_renew(capa, CLIENT_CAPA); +void ll_capa_close(struct inode *inode) +{ + struct ll_inode_info *lli = ll_i2info(inode); + + if ((ll_i2sbi(inode)->ll_flags & (LL_SBI_MDS_CAPA | LL_SBI_OSS_CAPA)) + == 0) + return; + + if (!S_ISREG(inode->i_mode)) + return; + + atomic_dec(&lli->lli_open_count); +} + +/* delete CAPA_OPC_OSS_TRUNC only */ +void ll_truncate_free_capa(struct obd_capa *ocapa) +{ if (!ocapa) - RETURN(-ENOMEM); + return; - spin_lock(&lli->lli_lock); - /* in case it was linked to lli_capas already */ - if (list_empty(&ocapa->c_lli_list)) - list_add(&ocapa->c_lli_list, &lli->lli_capas); - spin_unlock(&lli->lli_lock); + LASSERT(ocapa->c_capa.lc_opc & CAPA_OPC_OSS_TRUNC); + DEBUG_CAPA(D_SEC, &ocapa->c_capa, "free truncate"); - RETURN(0); + capa_put(ocapa); + spin_lock(&capa_lock); + ll_delete_capa(ocapa); + spin_unlock(&capa_lock); } -struct obd_capa *ll_get_capa(struct inode *inode, uid_t uid, int op) +void ll_clear_inode_capas(struct inode *inode) { struct ll_inode_info *lli = ll_i2info(inode); struct obd_capa *ocapa, *tmp; - ENTRY; - list_for_each_entry_safe(ocapa, tmp, &lli->lli_capas, c_lli_list) { - if (ocapa->c_capa.lc_ruid != uid) - continue; - if (ocapa->c_capa.lc_op != op) - continue; + spin_lock(&capa_lock); + ocapa = lli->lli_mds_capa; + if (ocapa) + ll_delete_capa(ocapa); + + list_for_each_entry_safe(ocapa, tmp, &lli->lli_oss_capas, + u.cli.lli_list) + ll_delete_capa(ocapa); + spin_unlock(&capa_lock); +} - RETURN(ocapa); - } - - RETURN(NULL); +void ll_print_capa_stat(struct ll_sb_info *sbi) +{ + if (sbi->ll_flags & (LL_SBI_MDS_CAPA | LL_SBI_OSS_CAPA)) + LCONSOLE_INFO("Fid capabilities renewed: %llu\n" + "Fid capabilities renewal ENOENT: %llu\n" + "Fid capabilities failed to renew: %llu\n" + "Fid capabilities renewal retries: %llu\n", + ll_capa_renewed, ll_capa_renewal_noent, + ll_capa_renewal_failed, ll_capa_renewal_retries); }