Whamcloud - gitweb
Constify instances of struct {lu,dt,md}_device_operations.
[fs/lustre-release.git] / lustre / cmm / mdc_object.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/cmm/mdc_object.c
37  *
38  * Lustre Cluster Metadata Manager (cmm)
39  *
40  * Author: Mike Pershin <tappro@clusterfs.com>
41  */
42
43 #ifndef EXPORT_SYMTAB
44 # define EXPORT_SYMTAB
45 #endif
46
47 #define DEBUG_SUBSYSTEM S_MDS
48 #include <obd_support.h>
49 #include <lustre_lib.h>
50 #include <obd_class.h>
51 #include <lustre_mdc.h>
52 #include "cmm_internal.h"
53 #include "mdc_internal.h"
54
55 static const struct md_object_operations mdc_mo_ops;
56 static const struct md_dir_operations mdc_dir_ops;
57 static const struct lu_object_operations mdc_obj_ops;
58
59 extern struct lu_context_key mdc_thread_key;
60
61 struct lu_object *mdc_object_alloc(const struct lu_env *env,
62                                    const struct lu_object_header *hdr,
63                                    struct lu_device *ld)
64 {
65         struct mdc_object *mco;
66         ENTRY;
67
68         OBD_ALLOC_PTR(mco);
69         if (mco != NULL) {
70                 struct lu_object *lo;
71
72                 lo = &mco->mco_obj.mo_lu;
73                 lu_object_init(lo, NULL, ld);
74                 mco->mco_obj.mo_ops = &mdc_mo_ops;
75                 mco->mco_obj.mo_dir_ops = &mdc_dir_ops;
76                 lo->lo_ops = &mdc_obj_ops;
77                 RETURN(lo);
78         } else
79                 RETURN(NULL);
80 }
81
82 static void mdc_object_free(const struct lu_env *env, struct lu_object *lo)
83 {
84         struct mdc_object *mco = lu2mdc_obj(lo);
85         lu_object_fini(lo);
86         OBD_FREE_PTR(mco);
87 }
88
89 static int mdc_object_init(const struct lu_env *env, struct lu_object *lo,
90                            const struct lu_object_conf *_)
91 {
92         ENTRY;
93         lo->lo_header->loh_attr |= LOHA_REMOTE;
94         RETURN(0);
95 }
96
97 static const struct lu_object_operations mdc_obj_ops = {
98         .loo_object_init    = mdc_object_init,
99         .loo_object_free    = mdc_object_free,
100 };
101
102 /* md_object_operations */
103 static
104 struct mdc_thread_info *mdc_info_get(const struct lu_env *env)
105 {
106         struct mdc_thread_info *mci;
107
108         mci = lu_context_key_get(&env->le_ctx, &mdc_thread_key);
109         LASSERT(mci);
110         return mci;
111 }
112
113 static
114 struct mdc_thread_info *mdc_info_init(const struct lu_env *env)
115 {
116         struct mdc_thread_info *mci = mdc_info_get(env);
117         memset(mci, 0, sizeof(*mci));
118         return mci;
119 }
120
121 static void mdc_body2attr(struct mdt_body *body, struct md_attr *ma)
122 {
123         struct lu_attr *la = &ma->ma_attr;
124         /* update time */
125         if (body->valid & OBD_MD_FLCTIME && body->ctime >= la->la_ctime) {
126                 la->la_ctime = body->ctime;
127                 if (body->valid & OBD_MD_FLMTIME)
128                         la->la_mtime = body->mtime;
129         }
130
131         if (body->valid & OBD_MD_FLMODE)
132                 la->la_mode = body->mode;
133         if (body->valid & OBD_MD_FLSIZE)
134                 la->la_size = body->size;
135         if (body->valid & OBD_MD_FLBLOCKS)
136                 la->la_blocks = body->blocks;
137         if (body->valid & OBD_MD_FLUID)
138                 la->la_uid = body->uid;
139         if (body->valid & OBD_MD_FLGID)
140                 la->la_gid = body->gid;
141         if (body->valid & OBD_MD_FLFLAGS)
142                 la->la_flags = body->flags;
143         if (body->valid & OBD_MD_FLNLINK)
144                 la->la_nlink = body->nlink;
145         if (body->valid & OBD_MD_FLRDEV)
146                 la->la_rdev = body->rdev;
147
148         la->la_valid = body->valid;
149         ma->ma_valid = MA_INODE;
150 }
151
152 static int mdc_req2attr_update(const struct lu_env *env,
153                                struct md_attr *ma)
154 {
155         struct mdc_thread_info *mci;
156         struct ptlrpc_request *req;
157         struct mdt_body *body;
158         struct lov_mds_md *md;
159         struct llog_cookie *cookie;
160         void *acl;
161
162         ENTRY;
163         mci = mdc_info_get(env);
164         req = mci->mci_req;
165         LASSERT(req);
166         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
167         LASSERT(body);
168         mdc_body2attr(body, ma);
169
170         if (body->valid & OBD_MD_FLMDSCAPA) {
171                 struct lustre_capa *capa;
172
173                 /* create for cross-ref will fetch mds capa from remote obj */
174                 capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA1);
175                 LASSERT(capa != NULL);
176                 LASSERT(ma->ma_capa != NULL);
177                 *ma->ma_capa = *capa;
178         }
179                 
180         if ((body->valid & OBD_MD_FLEASIZE) || (body->valid & OBD_MD_FLDIREA)) {
181                 if (body->eadatasize == 0) {
182                         CERROR("No size defined for easize field\n");
183                         RETURN(-EPROTO);
184                 }
185
186                 md = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD,
187                                                   body->eadatasize);
188                 if (md == NULL)
189                         RETURN(-EPROTO);
190
191                 LASSERT(ma->ma_lmm != NULL);
192                 LASSERT(ma->ma_lmm_size >= body->eadatasize); 
193                 ma->ma_lmm_size = body->eadatasize;
194                 memcpy(ma->ma_lmm, md, ma->ma_lmm_size);
195                 ma->ma_valid |= MA_LOV;
196         }
197
198         if (body->valid & OBD_MD_FLCOOKIE) {
199                 /*
200                  * ACL and cookie share the same body->aclsize, we need
201                  * to make sure that they both never come here.
202                  */
203                 LASSERT(!(body->valid & OBD_MD_FLACL));
204
205                 if (body->aclsize == 0) {
206                         CERROR("No size defined for cookie field\n");
207                         RETURN(-EPROTO);
208                 }
209
210                 cookie = req_capsule_server_sized_get(&req->rq_pill, 
211                                                       &RMF_LOGCOOKIES,
212                                                       body->aclsize);
213                 if (cookie == NULL)
214                         RETURN(-EPROTO);
215
216                 LASSERT(ma->ma_cookie != NULL);
217                 LASSERT(ma->ma_cookie_size == body->aclsize);
218                 memcpy(ma->ma_cookie, cookie, ma->ma_cookie_size);
219                 ma->ma_valid |= MA_COOKIE;
220         }
221
222 #ifdef CONFIG_FS_POSIX_ACL
223         if (body->valid & OBD_MD_FLACL) {
224                 if (body->aclsize == 0) {
225                         CERROR("No size defined for acl field\n");
226                         RETURN(-EPROTO);
227                 }
228
229                 acl = req_capsule_server_sized_get(&req->rq_pill, 
230                                                    &RMF_ACL,
231                                                    body->aclsize);
232                 if (acl == NULL)
233                         RETURN(-EPROTO);
234
235                 LASSERT(ma->ma_acl != NULL);
236                 LASSERT(ma->ma_acl_size == body->aclsize);
237                 memcpy(ma->ma_acl, acl, ma->ma_acl_size);
238                 ma->ma_valid |= MA_ACL_DEF;
239         }
240 #endif
241
242         RETURN(0);
243 }
244
245 static int mdc_attr_get(const struct lu_env *env, struct md_object *mo,
246                         struct md_attr *ma)
247 {
248         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
249         struct mdc_thread_info *mci;
250         int rc;
251         ENTRY;
252
253         mci = lu_context_key_get(&env->le_ctx, &mdc_thread_key);
254         LASSERT(mci);
255
256         memset(&mci->mci_opdata, 0, sizeof(mci->mci_opdata));
257
258         rc = md_getattr(mc->mc_desc.cl_exp, lu_object_fid(&mo->mo_lu),
259                         NULL, OBD_MD_FLMODE | OBD_MD_FLUID | OBD_MD_FLGID |
260                         OBD_MD_FLFLAGS | OBD_MD_FLCROSSREF, 0, &mci->mci_req);
261         if (rc == 0) {
262                 /* get attr from request */
263                 rc = mdc_req2attr_update(env, ma);
264         }
265
266         ptlrpc_req_finished(mci->mci_req);
267
268         RETURN(rc);
269 }
270
271 static inline struct timespec *mdc_attr_time(struct timespec *t, __u64 seconds)
272 {
273         t->tv_sec = seconds;
274         t->tv_nsec = 0;
275         return t;
276 }
277
278 /*
279  * XXX: It is only used for set ctime when rename's source on remote MDS.
280  */
281 static int mdc_attr_set(const struct lu_env *env, struct md_object *mo,
282                         const struct md_attr *ma)
283 {
284         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
285         const struct lu_attr *la = &ma->ma_attr;
286         struct mdc_thread_info *mci;
287         struct md_ucred *uc = md_ucred(env);
288         int rc;
289         ENTRY;
290
291         LASSERT(ma->ma_attr.la_valid & LA_CTIME);
292
293         mci = lu_context_key_get(&env->le_ctx, &mdc_thread_key);
294         LASSERT(mci);
295
296         memset(&mci->mci_opdata, 0, sizeof(mci->mci_opdata));
297
298         mci->mci_opdata.op_fid1 = *lu_object_fid(&mo->mo_lu);
299         mdc_attr_time(&mci->mci_opdata.op_attr.ia_ctime, la->la_ctime);
300         mci->mci_opdata.op_attr.ia_mode = la->la_mode;
301         mci->mci_opdata.op_attr.ia_valid = ATTR_CTIME_SET;
302         if (uc &&
303             ((uc->mu_valid == UCRED_OLD) || (uc->mu_valid == UCRED_NEW))) {
304                 mci->mci_opdata.op_fsuid = uc->mu_fsuid;
305                 mci->mci_opdata.op_fsgid = uc->mu_fsgid;
306                 mci->mci_opdata.op_cap = uc->mu_cap;
307                 if (uc->mu_ginfo || (uc->mu_valid == UCRED_OLD)) {
308                         mci->mci_opdata.op_suppgids[0] = uc->mu_suppgids[0];
309                         mci->mci_opdata.op_suppgids[1] = uc->mu_suppgids[1];
310                 } else {
311                         mci->mci_opdata.op_suppgids[0] =
312                                 mci->mci_opdata.op_suppgids[1] = -1;
313                 }
314         } else {
315                 mci->mci_opdata.op_fsuid = la->la_uid;
316                 mci->mci_opdata.op_fsgid = la->la_gid;
317                 mci->mci_opdata.op_cap = cfs_curproc_cap_pack();
318                 mci->mci_opdata.op_suppgids[0] =
319                                 mci->mci_opdata.op_suppgids[1] = -1;
320         }
321
322         rc = md_setattr(mc->mc_desc.cl_exp, &mci->mci_opdata,
323                         NULL, 0, NULL, 0, &mci->mci_req, NULL);
324
325         ptlrpc_req_finished(mci->mci_req);
326
327         RETURN(rc);
328 }
329
330 static int mdc_object_create(const struct lu_env *env,
331                              struct md_object *mo,
332                              const struct md_op_spec *spec,
333                              struct md_attr *ma)
334 {
335         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
336         struct lu_attr *la = &ma->ma_attr;
337         struct mdc_thread_info *mci;
338         const void *symname;
339         struct md_ucred *uc = md_ucred(env);
340         int rc, symlen;
341         uid_t uid;
342         gid_t gid;
343         cfs_cap_t cap;
344         ENTRY;
345
346         LASSERT(S_ISDIR(la->la_mode));
347         LASSERT(spec->u.sp_pfid != NULL);
348
349         mci = mdc_info_init(env);
350         mci->mci_opdata.op_bias = MDS_CROSS_REF;
351         mci->mci_opdata.op_fid2 = *lu_object_fid(&mo->mo_lu);
352         
353         /* Parent fid is needed to create dotdot on the remote node. */
354         mci->mci_opdata.op_fid1 = *(spec->u.sp_pfid);
355         mci->mci_opdata.op_mod_time = la->la_ctime;
356         if (uc &&
357             ((uc->mu_valid == UCRED_OLD) || (uc->mu_valid == UCRED_NEW))) {
358                 uid = uc->mu_fsuid;
359                 if (la->la_mode & S_ISGID)
360                         gid = la->la_gid;
361                 else
362                         gid = uc->mu_fsgid;
363                 cap = uc->mu_cap;
364                 if (uc->mu_ginfo || (uc->mu_valid == UCRED_OLD))
365                         mci->mci_opdata.op_suppgids[0] = uc->mu_suppgids[0];
366                 else
367                         mci->mci_opdata.op_suppgids[0] = -1;
368         } else {
369                 uid = la->la_uid;
370                 gid = la->la_gid;
371                 cap = 0;
372                 mci->mci_opdata.op_suppgids[0] = -1;
373         }
374
375         /* get data from spec */
376         if (spec->sp_cr_flags & MDS_CREATE_SLAVE_OBJ) {
377                 symname = spec->u.sp_ea.eadata;
378                 symlen = spec->u.sp_ea.eadatalen;
379                 mci->mci_opdata.op_fid1 = *(spec->u.sp_ea.fid);
380                 mci->mci_opdata.op_flags |= MDS_CREATE_SLAVE_OBJ;
381 #ifdef CONFIG_FS_POSIX_ACL
382         } else if (spec->sp_cr_flags & MDS_CREATE_RMT_ACL) {
383                 symname = spec->u.sp_ea.eadata;
384                 symlen = spec->u.sp_ea.eadatalen;
385                 mci->mci_opdata.op_fid1 = *(spec->u.sp_ea.fid);
386                 mci->mci_opdata.op_flags |= MDS_CREATE_RMT_ACL;
387 #endif
388         } else {
389                 symname = spec->u.sp_symname;
390                 symlen = symname ? strlen(symname) + 1 : 0;
391         }
392
393         rc = md_create(mc->mc_desc.cl_exp, &mci->mci_opdata,
394                        symname, symlen, la->la_mode, uid, gid,
395                        cap, la->la_rdev, &mci->mci_req);
396
397         if (rc == 0) {
398                 /* get attr from request */
399                 rc = mdc_req2attr_update(env, ma);
400         }
401
402         ptlrpc_req_finished(mci->mci_req);
403
404         RETURN(rc);
405 }
406
407 static int mdc_ref_add(const struct lu_env *env, struct md_object *mo,
408                        const struct md_attr *ma)
409 {
410         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
411         const struct lu_attr *la = &ma->ma_attr;
412         struct mdc_thread_info *mci;
413         struct md_ucred *uc = md_ucred(env);
414         int rc;
415         ENTRY;
416
417         mci = lu_context_key_get(&env->le_ctx, &mdc_thread_key);
418         LASSERT(mci);
419
420         memset(&mci->mci_opdata, 0, sizeof(mci->mci_opdata));
421         mci->mci_opdata.op_bias = MDS_CROSS_REF;
422         mci->mci_opdata.op_fid1 = *lu_object_fid(&mo->mo_lu);
423         mci->mci_opdata.op_mod_time = la->la_ctime;
424         if (uc &&
425             ((uc->mu_valid == UCRED_OLD) || (uc->mu_valid == UCRED_NEW))) {
426                 mci->mci_opdata.op_fsuid = uc->mu_fsuid;
427                 mci->mci_opdata.op_fsgid = uc->mu_fsgid;
428                 mci->mci_opdata.op_cap = uc->mu_cap;
429                 if (uc->mu_ginfo || (uc->mu_valid == UCRED_OLD)) {
430                         mci->mci_opdata.op_suppgids[0] = uc->mu_suppgids[0];
431                         mci->mci_opdata.op_suppgids[1] = uc->mu_suppgids[1];
432                 } else {
433                         mci->mci_opdata.op_suppgids[0] =
434                                 mci->mci_opdata.op_suppgids[1] = -1;
435                 }
436         } else {
437                 mci->mci_opdata.op_fsuid = la->la_uid;
438                 mci->mci_opdata.op_fsgid = la->la_gid;
439                 mci->mci_opdata.op_cap = cfs_curproc_cap_pack();
440                 mci->mci_opdata.op_suppgids[0] =
441                                 mci->mci_opdata.op_suppgids[1] = -1;
442         }
443
444
445         rc = md_link(mc->mc_desc.cl_exp, &mci->mci_opdata, &mci->mci_req);
446
447         ptlrpc_req_finished(mci->mci_req);
448
449         RETURN(rc);
450 }
451
452 static int mdc_ref_del(const struct lu_env *env, struct md_object *mo,
453                        struct md_attr *ma)
454 {
455         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
456         struct lu_attr *la = &ma->ma_attr;
457         struct mdc_thread_info *mci;
458         struct md_ucred *uc = md_ucred(env);
459         int rc;
460         ENTRY;
461
462         mci = mdc_info_init(env);
463         mci->mci_opdata.op_bias = MDS_CROSS_REF;
464         if (ma->ma_attr_flags & MDS_VTX_BYPASS)
465                 mci->mci_opdata.op_bias |= MDS_VTX_BYPASS;
466         else
467                 mci->mci_opdata.op_bias &= ~MDS_VTX_BYPASS;
468         mci->mci_opdata.op_fid1 = *lu_object_fid(&mo->mo_lu);
469         mci->mci_opdata.op_mode = la->la_mode;
470         mci->mci_opdata.op_mod_time = la->la_ctime;
471         if (uc &&
472             ((uc->mu_valid == UCRED_OLD) || (uc->mu_valid == UCRED_NEW))) {
473                 mci->mci_opdata.op_fsuid = uc->mu_fsuid;
474                 mci->mci_opdata.op_fsgid = uc->mu_fsgid;
475                 mci->mci_opdata.op_cap = uc->mu_cap;
476                 if (uc->mu_ginfo || (uc->mu_valid == UCRED_OLD))
477                         mci->mci_opdata.op_suppgids[0] = uc->mu_suppgids[0];
478                 else
479                         mci->mci_opdata.op_suppgids[0] = -1;
480         } else {
481                 mci->mci_opdata.op_fsuid = la->la_uid;
482                 mci->mci_opdata.op_fsgid = la->la_gid;
483                 mci->mci_opdata.op_cap = cfs_curproc_cap_pack();
484                 mci->mci_opdata.op_suppgids[0] = -1;
485         }
486
487         rc = md_unlink(mc->mc_desc.cl_exp, &mci->mci_opdata, &mci->mci_req);
488         if (rc == 0) {
489                 /* get attr from request */
490                 rc = mdc_req2attr_update(env, ma);
491         }
492
493         ptlrpc_req_finished(mci->mci_req);
494
495         RETURN(rc);
496 }
497
498 #ifdef HAVE_SPLIT_SUPPORT
499 int mdc_send_page(struct cmm_device *cm, const struct lu_env *env,
500                   struct md_object *mo, struct page *page, __u32 offset)
501 {
502         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
503         int rc;
504         ENTRY;
505
506         rc = mdc_sendpage(mc->mc_desc.cl_exp, lu_object_fid(&mo->mo_lu),
507                           page, offset);
508         CDEBUG(rc ? D_ERROR : D_INFO, "send page %p  offset %d fid "DFID
509                " rc %d \n", page, offset, PFID(lu_object_fid(&mo->mo_lu)), rc);
510         RETURN(rc);
511 }
512 #endif
513
514 static const struct md_object_operations mdc_mo_ops = {
515         .moo_attr_get       = mdc_attr_get,
516         .moo_attr_set       = mdc_attr_set,
517         .moo_object_create  = mdc_object_create,
518         .moo_ref_add        = mdc_ref_add,
519         .moo_ref_del        = mdc_ref_del,
520 };
521
522 /* md_dir_operations */
523 static int mdc_rename_tgt(const struct lu_env *env, struct md_object *mo_p,
524                           struct md_object *mo_t, const struct lu_fid *lf,
525                           const struct lu_name *lname, struct md_attr *ma)
526 {
527         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo_p));
528         struct lu_attr *la = &ma->ma_attr;
529         struct mdc_thread_info *mci;
530         struct md_ucred *uc = md_ucred(env);
531         int rc;
532         ENTRY;
533
534         mci = mdc_info_init(env);
535         mci->mci_opdata.op_bias = MDS_CROSS_REF;
536         if (ma->ma_attr_flags & MDS_VTX_BYPASS)
537                 mci->mci_opdata.op_bias |= MDS_VTX_BYPASS;
538         else
539                 mci->mci_opdata.op_bias &= ~MDS_VTX_BYPASS;
540         mci->mci_opdata.op_fid1 = *lu_object_fid(&mo_p->mo_lu);
541         mci->mci_opdata.op_fid2 = *lf;
542         mci->mci_opdata.op_mode = la->la_mode;
543         mci->mci_opdata.op_mod_time = la->la_ctime;
544         if (uc &&
545             ((uc->mu_valid == UCRED_OLD) || (uc->mu_valid == UCRED_NEW))) {
546                 mci->mci_opdata.op_fsuid = uc->mu_fsuid;
547                 mci->mci_opdata.op_fsgid = uc->mu_fsgid;
548                 mci->mci_opdata.op_cap = uc->mu_cap;
549                 if (uc->mu_ginfo || (uc->mu_valid == UCRED_OLD)) {
550                         mci->mci_opdata.op_suppgids[0] = uc->mu_suppgids[0];
551                         mci->mci_opdata.op_suppgids[1] = uc->mu_suppgids[1];
552                 } else {
553                         mci->mci_opdata.op_suppgids[0] =
554                                 mci->mci_opdata.op_suppgids[1] = -1;
555                 }
556         } else {
557                 mci->mci_opdata.op_fsuid = la->la_uid;
558                 mci->mci_opdata.op_fsgid = la->la_gid;
559                 mci->mci_opdata.op_cap = cfs_curproc_cap_pack();
560                 mci->mci_opdata.op_suppgids[0] =
561                                 mci->mci_opdata.op_suppgids[1] = -1;
562         }
563
564         rc = md_rename(mc->mc_desc.cl_exp, &mci->mci_opdata, NULL, 0,
565                        lname->ln_name, lname->ln_namelen, &mci->mci_req);
566         if (rc == 0) {
567                 /* get attr from request */
568                 mdc_req2attr_update(env, ma);
569         }
570
571         ptlrpc_req_finished(mci->mci_req);
572
573         RETURN(rc);
574 }
575 /* 
576  * Return resulting fid in sfid
577  * 0: fids are not relatives
578  * fid: fid at which search stopped
579  */
580 static int mdc_is_subdir(const struct lu_env *env, struct md_object *mo,
581                          const struct lu_fid *fid, struct lu_fid *sfid)
582 {
583         struct mdc_device *mc = md2mdc_dev(md_obj2dev(mo));
584         struct mdc_thread_info *mci;
585         struct mdt_body *body;
586         int rc;
587         ENTRY;
588
589         mci = mdc_info_init(env);
590
591         rc = md_is_subdir(mc->mc_desc.cl_exp, lu_object_fid(&mo->mo_lu),
592                           fid, &mci->mci_req);
593         if (rc == 0 || rc == -EREMOTE) {
594                 body = req_capsule_server_get(&mci->mci_req->rq_pill,
595                                               &RMF_MDT_BODY);
596                 LASSERT(body->valid & OBD_MD_FLID);
597         
598                 CDEBUG(D_INFO, "Remote mdo_is_subdir(), new src "DFID"\n",
599                        PFID(&body->fid1));
600                 *sfid = body->fid1;
601         }
602         ptlrpc_req_finished(mci->mci_req);
603         RETURN(rc);
604 }
605
606 static const struct md_dir_operations mdc_dir_ops = {
607         .mdo_is_subdir   = mdc_is_subdir,
608         .mdo_rename_tgt  = mdc_rename_tgt
609 };