4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/lov/lov_obd.c
38 * Author: Phil Schwan <phil@clusterfs.com>
39 * Author: Peter Braam <braam@clusterfs.com>
40 * Author: Mike Shaver <shaver@clusterfs.com>
41 * Author: Nathan Rutman <nathan@clusterfs.com>
44 #define DEBUG_SUBSYSTEM S_LOV
45 #include "../../include/linux/libcfs/libcfs.h"
47 #include "../include/obd_support.h"
48 #include "../include/lustre_lib.h"
49 #include "../include/lustre_net.h"
50 #include "../include/lustre/lustre_idl.h"
51 #include "../include/lustre_dlm.h"
52 #include "../include/lustre_mds.h"
53 #include "../include/obd_class.h"
54 #include "../include/lprocfs_status.h"
55 #include "../include/lustre_param.h"
56 #include "../include/cl_object.h"
57 #include "../include/lclient.h" /* for cl_client_lru */
58 #include "../include/lustre/ll_fiemap.h"
59 #include "../include/lustre_fid.h"
61 #include "lov_internal.h"
63 /* Keep a refcount of lov->tgt usage to prevent racing with addition/deletion.
64 Any function that expects lov_tgts to remain stationary must take a ref. */
65 static void lov_getref(struct obd_device
*obd
)
67 struct lov_obd
*lov
= &obd
->u
.lov
;
69 /* nobody gets through here until lov_putref is done */
70 mutex_lock(&lov
->lov_lock
);
71 atomic_inc(&lov
->lov_refcount
);
72 mutex_unlock(&lov
->lov_lock
);
76 static void __lov_del_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
);
78 static void lov_putref(struct obd_device
*obd
)
80 struct lov_obd
*lov
= &obd
->u
.lov
;
82 mutex_lock(&lov
->lov_lock
);
83 /* ok to dec to 0 more than once -- ltd_exp's will be null */
84 if (atomic_dec_and_test(&lov
->lov_refcount
) && lov
->lov_death_row
) {
87 struct lov_tgt_desc
*tgt
, *n
;
88 CDEBUG(D_CONFIG
, "destroying %d lov targets\n",
90 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
91 tgt
= lov
->lov_tgts
[i
];
93 if (!tgt
|| !tgt
->ltd_reap
)
95 list_add(&tgt
->ltd_kill
, &kill
);
96 /* XXX - right now there is a dependency on ld_tgt_count
97 * being the maximum tgt index for computing the
98 * mds_max_easize. So we can't shrink it. */
99 lov_ost_pool_remove(&lov
->lov_packed
, i
);
100 lov
->lov_tgts
[i
] = NULL
;
101 lov
->lov_death_row
--;
103 mutex_unlock(&lov
->lov_lock
);
105 list_for_each_entry_safe(tgt
, n
, &kill
, ltd_kill
) {
106 list_del(&tgt
->ltd_kill
);
108 __lov_del_obd(obd
, tgt
);
111 if (lov
->lov_tgts_kobj
)
112 kobject_put(lov
->lov_tgts_kobj
);
115 mutex_unlock(&lov
->lov_lock
);
119 static int lov_set_osc_active(struct obd_device
*obd
, struct obd_uuid
*uuid
,
120 enum obd_notify_event ev
);
121 static int lov_notify(struct obd_device
*obd
, struct obd_device
*watched
,
122 enum obd_notify_event ev
, void *data
);
125 #define MAX_STRING_SIZE 128
126 int lov_connect_obd(struct obd_device
*obd
, __u32 index
, int activate
,
127 struct obd_connect_data
*data
)
129 struct lov_obd
*lov
= &obd
->u
.lov
;
130 struct obd_uuid
*tgt_uuid
;
131 struct obd_device
*tgt_obd
;
132 static struct obd_uuid lov_osc_uuid
= { "LOV_OSC_UUID" };
133 struct obd_import
*imp
;
136 if (!lov
->lov_tgts
[index
])
139 tgt_uuid
= &lov
->lov_tgts
[index
]->ltd_uuid
;
140 tgt_obd
= lov
->lov_tgts
[index
]->ltd_obd
;
142 if (!tgt_obd
->obd_set_up
) {
143 CERROR("Target %s not set up\n", obd_uuid2str(tgt_uuid
));
147 /* override the sp_me from lov */
148 tgt_obd
->u
.cli
.cl_sp_me
= lov
->lov_sp_me
;
150 if (data
&& (data
->ocd_connect_flags
& OBD_CONNECT_INDEX
))
151 data
->ocd_index
= index
;
154 * Divine LOV knows that OBDs under it are OSCs.
156 imp
= tgt_obd
->u
.cli
.cl_import
;
159 tgt_obd
->obd_no_recov
= 0;
160 /* FIXME this is probably supposed to be
161 ptlrpc_set_import_active. Horrible naming. */
162 ptlrpc_activate_import(imp
);
165 rc
= obd_register_observer(tgt_obd
, obd
);
167 CERROR("Target %s register_observer error %d\n",
168 obd_uuid2str(tgt_uuid
), rc
);
173 if (imp
->imp_invalid
) {
174 CDEBUG(D_CONFIG
, "not connecting OSC %s; administratively disabled\n",
175 obd_uuid2str(tgt_uuid
));
179 rc
= obd_connect(NULL
, &lov
->lov_tgts
[index
]->ltd_exp
, tgt_obd
,
180 &lov_osc_uuid
, data
, NULL
);
181 if (rc
|| !lov
->lov_tgts
[index
]->ltd_exp
) {
182 CERROR("Target %s connect error %d\n",
183 obd_uuid2str(tgt_uuid
), rc
);
187 lov
->lov_tgts
[index
]->ltd_reap
= 0;
189 CDEBUG(D_CONFIG
, "Connected tgt idx %d %s (%s) %sactive\n", index
,
190 obd_uuid2str(tgt_uuid
), tgt_obd
->obd_name
, activate
? "":"in");
192 if (lov
->lov_tgts_kobj
)
193 /* Even if we failed, that's ok */
194 rc
= sysfs_create_link(lov
->lov_tgts_kobj
, &tgt_obd
->obd_kobj
,
200 static int lov_connect(const struct lu_env
*env
,
201 struct obd_export
**exp
, struct obd_device
*obd
,
202 struct obd_uuid
*cluuid
, struct obd_connect_data
*data
,
205 struct lov_obd
*lov
= &obd
->u
.lov
;
206 struct lov_tgt_desc
*tgt
;
207 struct lustre_handle conn
;
210 CDEBUG(D_CONFIG
, "connect #%d\n", lov
->lov_connects
);
212 rc
= class_connect(&conn
, obd
, cluuid
);
216 *exp
= class_conn2export(&conn
);
218 /* Why should there ever be more than 1 connect? */
220 LASSERT(lov
->lov_connects
== 1);
222 memset(&lov
->lov_ocd
, 0, sizeof(lov
->lov_ocd
));
224 lov
->lov_ocd
= *data
;
228 lov
->lov_tgts_kobj
= kobject_create_and_add("target_obds",
231 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
232 tgt
= lov
->lov_tgts
[i
];
233 if (!tgt
|| obd_uuid_empty(&tgt
->ltd_uuid
))
235 /* Flags will be lowest common denominator */
236 rc
= lov_connect_obd(obd
, i
, tgt
->ltd_activate
, &lov
->lov_ocd
);
238 CERROR("%s: lov connect tgt %d failed: %d\n",
239 obd
->obd_name
, i
, rc
);
242 /* connect to administrative disabled ost */
243 if (!lov
->lov_tgts
[i
]->ltd_exp
)
246 rc
= lov_notify(obd
, lov
->lov_tgts
[i
]->ltd_exp
->exp_obd
,
247 OBD_NOTIFY_CONNECT
, (void *)&i
);
249 CERROR("%s error sending notify %d\n",
258 static int lov_disconnect_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
)
260 struct lov_obd
*lov
= &obd
->u
.lov
;
261 struct obd_device
*osc_obd
;
264 osc_obd
= class_exp2obd(tgt
->ltd_exp
);
265 CDEBUG(D_CONFIG
, "%s: disconnecting target %s\n",
266 obd
->obd_name
, osc_obd
? osc_obd
->obd_name
: "NULL");
268 if (tgt
->ltd_active
) {
270 lov
->desc
.ld_active_tgt_count
--;
271 tgt
->ltd_exp
->exp_obd
->obd_inactive
= 1;
275 if (lov
->lov_tgts_kobj
)
276 sysfs_remove_link(lov
->lov_tgts_kobj
,
279 /* Pass it on to our clients.
280 * XXX This should be an argument to disconnect,
281 * XXX not a back-door flag on the OBD. Ah well.
283 osc_obd
->obd_force
= obd
->obd_force
;
284 osc_obd
->obd_fail
= obd
->obd_fail
;
285 osc_obd
->obd_no_recov
= obd
->obd_no_recov
;
288 obd_register_observer(osc_obd
, NULL
);
290 rc
= obd_disconnect(tgt
->ltd_exp
);
292 CERROR("Target %s disconnect error %d\n",
293 tgt
->ltd_uuid
.uuid
, rc
);
301 static int lov_disconnect(struct obd_export
*exp
)
303 struct obd_device
*obd
= class_exp2obd(exp
);
304 struct lov_obd
*lov
= &obd
->u
.lov
;
310 /* Only disconnect the underlying layers on the final disconnect. */
312 if (lov
->lov_connects
!= 0) {
313 /* why should there be more than 1 connect? */
314 CERROR("disconnect #%d\n", lov
->lov_connects
);
318 /* Let's hold another reference so lov_del_obd doesn't spin through
322 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
323 if (lov
->lov_tgts
[i
] && lov
->lov_tgts
[i
]->ltd_exp
) {
324 /* Disconnection is the last we know about an obd */
325 lov_del_target(obd
, i
, NULL
, lov
->lov_tgts
[i
]->ltd_gen
);
332 rc
= class_disconnect(exp
); /* bz 9811 */
338 * -EINVAL : UUID can't be found in the LOV's target list
339 * -ENOTCONN: The UUID is found, but the target connection is bad (!)
340 * -EBADF : The UUID is found, but the OBD is the wrong type (!)
341 * any >= 0 : is log target index
343 static int lov_set_osc_active(struct obd_device
*obd
, struct obd_uuid
*uuid
,
344 enum obd_notify_event ev
)
346 struct lov_obd
*lov
= &obd
->u
.lov
;
347 struct lov_tgt_desc
*tgt
;
348 int index
, activate
, active
;
350 CDEBUG(D_INFO
, "Searching in lov %p for uuid %s event(%d)\n",
351 lov
, uuid
->uuid
, ev
);
354 for (index
= 0; index
< lov
->desc
.ld_tgt_count
; index
++) {
355 tgt
= lov
->lov_tgts
[index
];
359 * LU-642, initially inactive OSC could miss the obd_connect,
360 * we make up for it here.
362 if (ev
== OBD_NOTIFY_ACTIVATE
&& tgt
->ltd_exp
== NULL
&&
363 obd_uuid_equals(uuid
, &tgt
->ltd_uuid
)) {
364 struct obd_uuid lov_osc_uuid
= {"LOV_OSC_UUID"};
366 obd_connect(NULL
, &tgt
->ltd_exp
, tgt
->ltd_obd
,
367 &lov_osc_uuid
, &lov
->lov_ocd
, NULL
);
372 CDEBUG(D_INFO
, "lov idx %d is %s conn %#llx\n",
373 index
, obd_uuid2str(&tgt
->ltd_uuid
),
374 tgt
->ltd_exp
->exp_handle
.h_cookie
);
375 if (obd_uuid_equals(uuid
, &tgt
->ltd_uuid
))
379 if (index
== lov
->desc
.ld_tgt_count
) {
384 if (ev
== OBD_NOTIFY_DEACTIVATE
|| ev
== OBD_NOTIFY_ACTIVATE
) {
385 activate
= (ev
== OBD_NOTIFY_ACTIVATE
) ? 1 : 0;
387 if (lov
->lov_tgts
[index
]->ltd_activate
== activate
) {
388 CDEBUG(D_INFO
, "OSC %s already %sactivate!\n",
389 uuid
->uuid
, activate
? "" : "de");
391 lov
->lov_tgts
[index
]->ltd_activate
= activate
;
392 CDEBUG(D_CONFIG
, "%sactivate OSC %s\n",
393 activate
? "" : "de", obd_uuid2str(uuid
));
396 } else if (ev
== OBD_NOTIFY_INACTIVE
|| ev
== OBD_NOTIFY_ACTIVE
) {
397 active
= (ev
== OBD_NOTIFY_ACTIVE
) ? 1 : 0;
399 if (lov
->lov_tgts
[index
]->ltd_active
== active
) {
400 CDEBUG(D_INFO
, "OSC %s already %sactive!\n",
401 uuid
->uuid
, active
? "" : "in");
404 CDEBUG(D_CONFIG
, "Marking OSC %s %sactive\n",
405 obd_uuid2str(uuid
), active
? "" : "in");
408 lov
->lov_tgts
[index
]->ltd_active
= active
;
410 lov
->desc
.ld_active_tgt_count
++;
411 lov
->lov_tgts
[index
]->ltd_exp
->exp_obd
->obd_inactive
= 0;
413 lov
->desc
.ld_active_tgt_count
--;
414 lov
->lov_tgts
[index
]->ltd_exp
->exp_obd
->obd_inactive
= 1;
417 CERROR("Unknown event(%d) for uuid %s", ev
, uuid
->uuid
);
425 static int lov_notify(struct obd_device
*obd
, struct obd_device
*watched
,
426 enum obd_notify_event ev
, void *data
)
429 struct lov_obd
*lov
= &obd
->u
.lov
;
431 down_read(&lov
->lov_notify_lock
);
432 if (!lov
->lov_connects
) {
433 up_read(&lov
->lov_notify_lock
);
437 if (ev
== OBD_NOTIFY_ACTIVE
|| ev
== OBD_NOTIFY_INACTIVE
||
438 ev
== OBD_NOTIFY_ACTIVATE
|| ev
== OBD_NOTIFY_DEACTIVATE
) {
439 struct obd_uuid
*uuid
;
443 if (strcmp(watched
->obd_type
->typ_name
, LUSTRE_OSC_NAME
)) {
444 up_read(&lov
->lov_notify_lock
);
445 CERROR("unexpected notification of %s %s!\n",
446 watched
->obd_type
->typ_name
,
450 uuid
= &watched
->u
.cli
.cl_target_uuid
;
452 /* Set OSC as active before notifying the observer, so the
453 * observer can use the OSC normally.
455 rc
= lov_set_osc_active(obd
, uuid
, ev
);
457 up_read(&lov
->lov_notify_lock
);
458 CERROR("event(%d) of %s failed: %d\n", ev
,
459 obd_uuid2str(uuid
), rc
);
462 /* active event should be pass lov target index as data */
466 /* Pass the notification up the chain. */
468 rc
= obd_notify_observer(obd
, watched
, ev
, data
);
470 /* NULL watched means all osc's in the lov (only for syncs) */
471 /* sync event should be send lov idx as data */
472 struct lov_obd
*lov
= &obd
->u
.lov
;
476 is_sync
= (ev
== OBD_NOTIFY_SYNC
) ||
477 (ev
== OBD_NOTIFY_SYNC_NONBLOCK
);
480 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
481 if (!lov
->lov_tgts
[i
])
484 /* don't send sync event if target not
485 * connected/activated */
486 if (is_sync
&& !lov
->lov_tgts
[i
]->ltd_active
)
489 rc
= obd_notify_observer(obd
, lov
->lov_tgts
[i
]->ltd_obd
,
492 CERROR("%s: notify %s of %s failed %d\n",
494 obd
->obd_observer
->obd_name
,
495 lov
->lov_tgts
[i
]->ltd_obd
->obd_name
,
502 up_read(&lov
->lov_notify_lock
);
506 static int lov_add_target(struct obd_device
*obd
, struct obd_uuid
*uuidp
,
507 __u32 index
, int gen
, int active
)
509 struct lov_obd
*lov
= &obd
->u
.lov
;
510 struct lov_tgt_desc
*tgt
;
511 struct obd_device
*tgt_obd
;
514 CDEBUG(D_CONFIG
, "uuid:%s idx:%d gen:%d active:%d\n",
515 uuidp
->uuid
, index
, gen
, active
);
518 CERROR("request to add OBD %s with invalid generation: %d\n",
523 tgt_obd
= class_find_client_obd(uuidp
, LUSTRE_OSC_NAME
,
528 mutex_lock(&lov
->lov_lock
);
530 if ((index
< lov
->lov_tgt_size
) && (lov
->lov_tgts
[index
] != NULL
)) {
531 tgt
= lov
->lov_tgts
[index
];
532 CERROR("UUID %s already assigned at LOV target index %d\n",
533 obd_uuid2str(&tgt
->ltd_uuid
), index
);
534 mutex_unlock(&lov
->lov_lock
);
538 if (index
>= lov
->lov_tgt_size
) {
539 /* We need to reallocate the lov target array. */
540 struct lov_tgt_desc
**newtgts
, **old
= NULL
;
541 __u32 newsize
, oldsize
= 0;
543 newsize
= max_t(__u32
, lov
->lov_tgt_size
, 2);
544 while (newsize
< index
+ 1)
546 newtgts
= kcalloc(newsize
, sizeof(*newtgts
), GFP_NOFS
);
547 if (newtgts
== NULL
) {
548 mutex_unlock(&lov
->lov_lock
);
552 if (lov
->lov_tgt_size
) {
553 memcpy(newtgts
, lov
->lov_tgts
, sizeof(*newtgts
) *
556 oldsize
= lov
->lov_tgt_size
;
559 lov
->lov_tgts
= newtgts
;
560 lov
->lov_tgt_size
= newsize
;
564 CDEBUG(D_CONFIG
, "tgts: %p size: %d\n",
565 lov
->lov_tgts
, lov
->lov_tgt_size
);
568 tgt
= kzalloc(sizeof(*tgt
), GFP_NOFS
);
570 mutex_unlock(&lov
->lov_lock
);
574 rc
= lov_ost_pool_add(&lov
->lov_packed
, index
, lov
->lov_tgt_size
);
576 mutex_unlock(&lov
->lov_lock
);
581 tgt
->ltd_uuid
= *uuidp
;
582 tgt
->ltd_obd
= tgt_obd
;
583 /* XXX - add a sanity check on the generation number. */
585 tgt
->ltd_index
= index
;
586 tgt
->ltd_activate
= active
;
587 lov
->lov_tgts
[index
] = tgt
;
588 if (index
>= lov
->desc
.ld_tgt_count
)
589 lov
->desc
.ld_tgt_count
= index
+ 1;
591 mutex_unlock(&lov
->lov_lock
);
593 CDEBUG(D_CONFIG
, "idx=%d ltd_gen=%d ld_tgt_count=%d\n",
594 index
, tgt
->ltd_gen
, lov
->desc
.ld_tgt_count
);
596 rc
= obd_notify(obd
, tgt_obd
, OBD_NOTIFY_CREATE
, &index
);
598 if (lov
->lov_connects
== 0) {
599 /* lov_connect hasn't been called yet. We'll do the
600 lov_connect_obd on this target when that fn first runs,
601 because we don't know the connect flags yet. */
607 rc
= lov_connect_obd(obd
, index
, active
, &lov
->lov_ocd
);
611 /* connect to administrative disabled ost */
617 if (lov
->lov_cache
!= NULL
) {
618 rc
= obd_set_info_async(NULL
, tgt
->ltd_exp
,
619 sizeof(KEY_CACHE_SET
), KEY_CACHE_SET
,
620 sizeof(struct cl_client_cache
), lov
->lov_cache
,
626 rc
= lov_notify(obd
, tgt
->ltd_exp
->exp_obd
,
627 active
? OBD_NOTIFY_CONNECT
: OBD_NOTIFY_INACTIVE
,
632 CERROR("add failed (%d), deleting %s\n", rc
,
633 obd_uuid2str(&tgt
->ltd_uuid
));
634 lov_del_target(obd
, index
, NULL
, 0);
640 /* Schedule a target for deletion */
641 int lov_del_target(struct obd_device
*obd
, __u32 index
,
642 struct obd_uuid
*uuidp
, int gen
)
644 struct lov_obd
*lov
= &obd
->u
.lov
;
645 int count
= lov
->desc
.ld_tgt_count
;
648 if (index
>= count
) {
649 CERROR("LOV target index %d >= number of LOV OBDs %d.\n",
654 /* to make sure there's no ongoing lov_notify() now */
655 down_write(&lov
->lov_notify_lock
);
658 if (!lov
->lov_tgts
[index
]) {
659 CERROR("LOV target at index %d is not setup.\n", index
);
664 if (uuidp
&& !obd_uuid_equals(uuidp
, &lov
->lov_tgts
[index
]->ltd_uuid
)) {
665 CERROR("LOV target UUID %s at index %d doesn't match %s.\n",
666 lov_uuid2str(lov
, index
), index
,
667 obd_uuid2str(uuidp
));
672 CDEBUG(D_CONFIG
, "uuid: %s idx: %d gen: %d exp: %p active: %d\n",
673 lov_uuid2str(lov
, index
), index
,
674 lov
->lov_tgts
[index
]->ltd_gen
, lov
->lov_tgts
[index
]->ltd_exp
,
675 lov
->lov_tgts
[index
]->ltd_active
);
677 lov
->lov_tgts
[index
]->ltd_reap
= 1;
678 lov
->lov_death_row
++;
679 /* we really delete it from obd_putref */
682 up_write(&lov
->lov_notify_lock
);
687 static void __lov_del_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
)
689 struct obd_device
*osc_obd
;
692 LASSERT(tgt
->ltd_reap
);
694 osc_obd
= class_exp2obd(tgt
->ltd_exp
);
696 CDEBUG(D_CONFIG
, "Removing tgt %s : %s\n",
698 osc_obd
? osc_obd
->obd_name
: "<no obd>");
701 lov_disconnect_obd(obd
, tgt
);
705 /* Manual cleanup - no cleanup logs to clean up the osc's. We must
706 do it ourselves. And we can't do it from lov_cleanup,
707 because we just lost our only reference to it. */
709 class_manual_cleanup(osc_obd
);
712 void lov_fix_desc_stripe_size(__u64
*val
)
714 if (*val
< LOV_MIN_STRIPE_SIZE
) {
716 LCONSOLE_INFO("Increasing default stripe size to minimum %u\n",
717 LOV_DESC_STRIPE_SIZE_DEFAULT
);
718 *val
= LOV_DESC_STRIPE_SIZE_DEFAULT
;
719 } else if (*val
& (LOV_MIN_STRIPE_SIZE
- 1)) {
720 *val
&= ~(LOV_MIN_STRIPE_SIZE
- 1);
721 LCONSOLE_WARN("Changing default stripe size to %llu (a multiple of %u)\n",
722 *val
, LOV_MIN_STRIPE_SIZE
);
726 void lov_fix_desc_stripe_count(__u32
*val
)
732 void lov_fix_desc_pattern(__u32
*val
)
734 /* from lov_setstripe */
735 if ((*val
!= 0) && (*val
!= LOV_PATTERN_RAID0
)) {
736 LCONSOLE_WARN("Unknown stripe pattern: %#x\n", *val
);
741 void lov_fix_desc_qos_maxage(__u32
*val
)
744 *val
= LOV_DESC_QOS_MAXAGE_DEFAULT
;
747 void lov_fix_desc(struct lov_desc
*desc
)
749 lov_fix_desc_stripe_size(&desc
->ld_default_stripe_size
);
750 lov_fix_desc_stripe_count(&desc
->ld_default_stripe_count
);
751 lov_fix_desc_pattern(&desc
->ld_pattern
);
752 lov_fix_desc_qos_maxage(&desc
->ld_qos_maxage
);
755 int lov_setup(struct obd_device
*obd
, struct lustre_cfg
*lcfg
)
757 struct lprocfs_static_vars lvars
= { NULL
};
758 struct lov_desc
*desc
;
759 struct lov_obd
*lov
= &obd
->u
.lov
;
762 if (LUSTRE_CFG_BUFLEN(lcfg
, 1) < 1) {
763 CERROR("LOV setup requires a descriptor\n");
767 desc
= (struct lov_desc
*)lustre_cfg_buf(lcfg
, 1);
769 if (sizeof(*desc
) > LUSTRE_CFG_BUFLEN(lcfg
, 1)) {
770 CERROR("descriptor size wrong: %d > %d\n",
771 (int)sizeof(*desc
), LUSTRE_CFG_BUFLEN(lcfg
, 1));
775 if (desc
->ld_magic
!= LOV_DESC_MAGIC
) {
776 if (desc
->ld_magic
== __swab32(LOV_DESC_MAGIC
)) {
777 CDEBUG(D_OTHER
, "%s: Swabbing lov desc %p\n",
778 obd
->obd_name
, desc
);
779 lustre_swab_lov_desc(desc
);
781 CERROR("%s: Bad lov desc magic: %#x\n",
782 obd
->obd_name
, desc
->ld_magic
);
789 desc
->ld_active_tgt_count
= 0;
791 lov
->lov_tgt_size
= 0;
793 mutex_init(&lov
->lov_lock
);
794 atomic_set(&lov
->lov_refcount
, 0);
795 lov
->lov_sp_me
= LUSTRE_SP_CLI
;
797 init_rwsem(&lov
->lov_notify_lock
);
799 lov
->lov_pools_hash_body
= cfs_hash_create("POOLS", HASH_POOLS_CUR_BITS
,
801 HASH_POOLS_BKT_BITS
, 0,
804 &pool_hash_operations
,
806 INIT_LIST_HEAD(&lov
->lov_pool_list
);
807 lov
->lov_pool_count
= 0;
808 rc
= lov_ost_pool_init(&lov
->lov_packed
, 0);
812 lprocfs_lov_init_vars(&lvars
);
813 lprocfs_obd_setup(obd
, lvars
.obd_vars
, lvars
.sysfs_vars
);
815 rc
= ldebugfs_seq_create(obd
->obd_debugfs_entry
, "target_obd",
816 0444, &lov_proc_target_fops
, obd
);
818 CWARN("Error adding the target_obd file\n");
820 lov
->lov_pool_debugfs_entry
= ldebugfs_register("pools",
821 obd
->obd_debugfs_entry
,
829 static int lov_precleanup(struct obd_device
*obd
, enum obd_cleanup_stage stage
)
831 struct lov_obd
*lov
= &obd
->u
.lov
;
834 case OBD_CLEANUP_EARLY
: {
836 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
837 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_active
)
839 obd_precleanup(class_exp2obd(lov
->lov_tgts
[i
]->ltd_exp
),
851 static int lov_cleanup(struct obd_device
*obd
)
853 struct lov_obd
*lov
= &obd
->u
.lov
;
854 struct list_head
*pos
, *tmp
;
855 struct pool_desc
*pool
;
857 list_for_each_safe(pos
, tmp
, &lov
->lov_pool_list
) {
858 pool
= list_entry(pos
, struct pool_desc
, pool_list
);
859 /* free pool structs */
860 CDEBUG(D_INFO
, "delete pool %p\n", pool
);
861 /* In the function below, .hs_keycmp resolves to
862 * pool_hashkey_keycmp() */
863 /* coverity[overrun-buffer-val] */
864 lov_pool_del(obd
, pool
->pool_name
);
866 cfs_hash_putref(lov
->lov_pools_hash_body
);
867 lov_ost_pool_free(&lov
->lov_packed
);
869 lprocfs_obd_cleanup(obd
);
873 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
874 if (!lov
->lov_tgts
[i
])
877 /* Inactive targets may never have connected */
878 if (lov
->lov_tgts
[i
]->ltd_active
||
879 atomic_read(&lov
->lov_refcount
))
880 /* We should never get here - these
881 should have been removed in the
883 CERROR("lov tgt %d not cleaned! deathrow=%d, lovrc=%d\n",
884 i
, lov
->lov_death_row
,
885 atomic_read(&lov
->lov_refcount
));
886 lov_del_target(obd
, i
, NULL
, 0);
889 kfree(lov
->lov_tgts
);
890 lov
->lov_tgt_size
= 0;
895 int lov_process_config_base(struct obd_device
*obd
, struct lustre_cfg
*lcfg
,
896 __u32
*indexp
, int *genp
)
898 struct obd_uuid obd_uuid
;
902 switch (cmd
= lcfg
->lcfg_command
) {
903 case LCFG_LOV_ADD_OBD
:
904 case LCFG_LOV_ADD_INA
:
905 case LCFG_LOV_DEL_OBD
: {
908 /* lov_modify_tgts add 0:lov_mdsA 1:ost1_UUID 2:0 3:1 */
909 if (LUSTRE_CFG_BUFLEN(lcfg
, 1) > sizeof(obd_uuid
.uuid
)) {
914 obd_str2uuid(&obd_uuid
, lustre_cfg_buf(lcfg
, 1));
916 if (sscanf(lustre_cfg_buf(lcfg
, 2), "%d", indexp
) != 1) {
920 if (sscanf(lustre_cfg_buf(lcfg
, 3), "%d", genp
) != 1) {
926 if (cmd
== LCFG_LOV_ADD_OBD
)
927 rc
= lov_add_target(obd
, &obd_uuid
, index
, gen
, 1);
928 else if (cmd
== LCFG_LOV_ADD_INA
)
929 rc
= lov_add_target(obd
, &obd_uuid
, index
, gen
, 0);
931 rc
= lov_del_target(obd
, index
, &obd_uuid
, gen
);
935 struct lprocfs_static_vars lvars
= { NULL
};
936 struct lov_desc
*desc
= &(obd
->u
.lov
.desc
);
943 lprocfs_lov_init_vars(&lvars
);
945 rc
= class_process_proc_param(PARAM_LOV
, lvars
.obd_vars
,
958 CERROR("Unknown command: %d\n", lcfg
->lcfg_command
);
968 static int lov_recreate(struct obd_export
*exp
, struct obdo
*src_oa
,
969 struct lov_stripe_md
**ea
, struct obd_trans_info
*oti
)
971 struct lov_stripe_md
*obj_mdp
, *lsm
;
972 struct lov_obd
*lov
= &exp
->exp_obd
->u
.lov
;
976 LASSERT(src_oa
->o_valid
& OBD_MD_FLFLAGS
&&
977 src_oa
->o_flags
& OBD_FL_RECREATE_OBJS
);
979 obj_mdp
= kzalloc(sizeof(*obj_mdp
), GFP_NOFS
);
983 ost_idx
= src_oa
->o_nlink
;
989 if (ost_idx
>= lov
->desc
.ld_tgt_count
||
990 !lov
->lov_tgts
[ost_idx
]) {
995 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
996 struct lov_oinfo
*loi
= lsm
->lsm_oinfo
[i
];
998 if (lov_oinfo_is_dummy(loi
))
1001 if (loi
->loi_ost_idx
== ost_idx
) {
1002 if (ostid_id(&loi
->loi_oi
) != ostid_id(&src_oa
->o_oi
)) {
1009 if (i
== lsm
->lsm_stripe_count
) {
1014 rc
= obd_create(NULL
, lov
->lov_tgts
[ost_idx
]->ltd_exp
,
1015 src_oa
, &obj_mdp
, oti
);
1021 /* the LOV expects oa->o_id to be set to the LOV object id */
1022 static int lov_create(const struct lu_env
*env
, struct obd_export
*exp
,
1023 struct obdo
*src_oa
, struct lov_stripe_md
**ea
,
1024 struct obd_trans_info
*oti
)
1026 struct lov_obd
*lov
;
1029 LASSERT(ea
!= NULL
);
1033 if ((src_oa
->o_valid
& OBD_MD_FLFLAGS
) &&
1034 src_oa
->o_flags
== OBD_FL_DELORPHAN
) {
1035 /* should be used with LOV anymore */
1039 lov
= &exp
->exp_obd
->u
.lov
;
1040 if (!lov
->desc
.ld_active_tgt_count
)
1043 obd_getref(exp
->exp_obd
);
1044 /* Recreate a specific object id at the given OST index */
1045 if ((src_oa
->o_valid
& OBD_MD_FLFLAGS
) &&
1046 (src_oa
->o_flags
& OBD_FL_RECREATE_OBJS
)) {
1047 rc
= lov_recreate(exp
, src_oa
, ea
, oti
);
1050 obd_putref(exp
->exp_obd
);
1054 #define ASSERT_LSM_MAGIC(lsmp) \
1056 LASSERT((lsmp) != NULL); \
1057 LASSERTF(((lsmp)->lsm_magic == LOV_MAGIC_V1 || \
1058 (lsmp)->lsm_magic == LOV_MAGIC_V3), \
1059 "%p->lsm_magic=%x\n", (lsmp), (lsmp)->lsm_magic); \
1062 static int lov_destroy(const struct lu_env
*env
, struct obd_export
*exp
,
1063 struct obdo
*oa
, struct lov_stripe_md
*lsm
,
1064 struct obd_trans_info
*oti
, struct obd_export
*md_exp
,
1067 struct lov_request_set
*set
;
1068 struct obd_info oinfo
;
1069 struct lov_request
*req
;
1070 struct list_head
*pos
;
1071 struct lov_obd
*lov
;
1072 int rc
= 0, err
= 0;
1074 ASSERT_LSM_MAGIC(lsm
);
1076 if (!exp
|| !exp
->exp_obd
)
1079 if (oa
->o_valid
& OBD_MD_FLCOOKIE
) {
1081 LASSERT(oti
->oti_logcookies
);
1084 lov
= &exp
->exp_obd
->u
.lov
;
1085 obd_getref(exp
->exp_obd
);
1086 rc
= lov_prep_destroy_set(exp
, &oinfo
, oa
, lsm
, oti
, &set
);
1090 list_for_each(pos
, &set
->set_list
) {
1091 req
= list_entry(pos
, struct lov_request
, rq_link
);
1093 if (oa
->o_valid
& OBD_MD_FLCOOKIE
)
1094 oti
->oti_logcookies
= set
->set_cookies
+ req
->rq_stripe
;
1096 err
= obd_destroy(env
, lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1097 req
->rq_oi
.oi_oa
, NULL
, oti
, NULL
, capa
);
1098 err
= lov_update_common_set(set
, req
, err
);
1100 CERROR("%s: destroying objid "DOSTID
" subobj "
1101 DOSTID
" on OST idx %d: rc = %d\n",
1102 exp
->exp_obd
->obd_name
, POSTID(&oa
->o_oi
),
1103 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1111 LASSERT(lsm_op_find(lsm
->lsm_magic
) != NULL
);
1112 rc
= lsm_op_find(lsm
->lsm_magic
)->lsm_destroy(lsm
, oa
, md_exp
);
1114 err
= lov_fini_destroy_set(set
);
1116 obd_putref(exp
->exp_obd
);
1117 return rc
? rc
: err
;
1120 static int lov_getattr_interpret(struct ptlrpc_request_set
*rqset
,
1123 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1126 /* don't do attribute merge if this async op failed */
1128 atomic_set(&lovset
->set_completes
, 0);
1129 err
= lov_fini_getattr_set(lovset
);
1130 return rc
? rc
: err
;
1133 static int lov_getattr_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1134 struct ptlrpc_request_set
*rqset
)
1136 struct lov_request_set
*lovset
;
1137 struct lov_obd
*lov
;
1138 struct list_head
*pos
;
1139 struct lov_request
*req
;
1143 ASSERT_LSM_MAGIC(oinfo
->oi_md
);
1145 if (!exp
|| !exp
->exp_obd
)
1148 lov
= &exp
->exp_obd
->u
.lov
;
1150 rc
= lov_prep_getattr_set(exp
, oinfo
, &lovset
);
1154 CDEBUG(D_INFO
, "objid "DOSTID
": %ux%u byte stripes\n",
1155 POSTID(&oinfo
->oi_md
->lsm_oi
), oinfo
->oi_md
->lsm_stripe_count
,
1156 oinfo
->oi_md
->lsm_stripe_size
);
1158 list_for_each(pos
, &lovset
->set_list
) {
1159 req
= list_entry(pos
, struct lov_request
, rq_link
);
1161 CDEBUG(D_INFO
, "objid " DOSTID
"[%d] has subobj " DOSTID
" at idx%u\n",
1162 POSTID(&oinfo
->oi_oa
->o_oi
), req
->rq_stripe
,
1163 POSTID(&req
->rq_oi
.oi_oa
->o_oi
), req
->rq_idx
);
1164 rc
= obd_getattr_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1165 &req
->rq_oi
, rqset
);
1167 CERROR("%s: getattr objid "DOSTID
" subobj"
1168 DOSTID
" on OST idx %d: rc = %d\n",
1169 exp
->exp_obd
->obd_name
,
1170 POSTID(&oinfo
->oi_oa
->o_oi
),
1171 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1177 if (!list_empty(&rqset
->set_requests
)) {
1179 LASSERT(rqset
->set_interpret
== NULL
);
1180 rqset
->set_interpret
= lov_getattr_interpret
;
1181 rqset
->set_arg
= (void *)lovset
;
1186 atomic_set(&lovset
->set_completes
, 0);
1187 err
= lov_fini_getattr_set(lovset
);
1188 return rc
? rc
: err
;
1191 static int lov_setattr_interpret(struct ptlrpc_request_set
*rqset
,
1194 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1198 atomic_set(&lovset
->set_completes
, 0);
1199 err
= lov_fini_setattr_set(lovset
);
1200 return rc
? rc
: err
;
1203 /* If @oti is given, the request goes from MDS and responses from OSTs are not
1204 needed. Otherwise, a client is waiting for responses. */
1205 static int lov_setattr_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1206 struct obd_trans_info
*oti
,
1207 struct ptlrpc_request_set
*rqset
)
1209 struct lov_request_set
*set
;
1210 struct lov_request
*req
;
1211 struct list_head
*pos
;
1212 struct lov_obd
*lov
;
1216 ASSERT_LSM_MAGIC(oinfo
->oi_md
);
1217 if (oinfo
->oi_oa
->o_valid
& OBD_MD_FLCOOKIE
) {
1219 LASSERT(oti
->oti_logcookies
);
1222 if (!exp
|| !exp
->exp_obd
)
1225 lov
= &exp
->exp_obd
->u
.lov
;
1226 rc
= lov_prep_setattr_set(exp
, oinfo
, oti
, &set
);
1230 CDEBUG(D_INFO
, "objid "DOSTID
": %ux%u byte stripes\n",
1231 POSTID(&oinfo
->oi_md
->lsm_oi
),
1232 oinfo
->oi_md
->lsm_stripe_count
,
1233 oinfo
->oi_md
->lsm_stripe_size
);
1235 list_for_each(pos
, &set
->set_list
) {
1236 req
= list_entry(pos
, struct lov_request
, rq_link
);
1238 if (oinfo
->oi_oa
->o_valid
& OBD_MD_FLCOOKIE
)
1239 oti
->oti_logcookies
= set
->set_cookies
+ req
->rq_stripe
;
1241 CDEBUG(D_INFO
, "objid " DOSTID
"[%d] has subobj " DOSTID
" at idx%u\n",
1242 POSTID(&oinfo
->oi_oa
->o_oi
), req
->rq_stripe
,
1243 POSTID(&req
->rq_oi
.oi_oa
->o_oi
), req
->rq_idx
);
1245 rc
= obd_setattr_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1246 &req
->rq_oi
, oti
, rqset
);
1248 CERROR("error: setattr objid "DOSTID
" subobj"
1249 DOSTID
" on OST idx %d: rc = %d\n",
1250 POSTID(&set
->set_oi
->oi_oa
->o_oi
),
1251 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1257 /* If we are not waiting for responses on async requests, return. */
1258 if (rc
|| !rqset
|| list_empty(&rqset
->set_requests
)) {
1261 atomic_set(&set
->set_completes
, 0);
1262 err
= lov_fini_setattr_set(set
);
1263 return rc
? rc
: err
;
1266 LASSERT(rqset
->set_interpret
== NULL
);
1267 rqset
->set_interpret
= lov_setattr_interpret
;
1268 rqset
->set_arg
= (void *)set
;
1273 /* find any ldlm lock of the inode in lov
1277 static int lov_find_cbdata(struct obd_export
*exp
,
1278 struct lov_stripe_md
*lsm
, ldlm_iterator_t it
,
1281 struct lov_obd
*lov
;
1284 ASSERT_LSM_MAGIC(lsm
);
1286 if (!exp
|| !exp
->exp_obd
)
1289 lov
= &exp
->exp_obd
->u
.lov
;
1290 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1291 struct lov_stripe_md submd
;
1292 struct lov_oinfo
*loi
= lsm
->lsm_oinfo
[i
];
1294 if (lov_oinfo_is_dummy(loi
))
1297 if (!lov
->lov_tgts
[loi
->loi_ost_idx
]) {
1298 CDEBUG(D_HA
, "lov idx %d NULL\n", loi
->loi_ost_idx
);
1302 submd
.lsm_oi
= loi
->loi_oi
;
1303 submd
.lsm_stripe_count
= 0;
1304 rc
= obd_find_cbdata(lov
->lov_tgts
[loi
->loi_ost_idx
]->ltd_exp
,
1312 int lov_statfs_interpret(struct ptlrpc_request_set
*rqset
, void *data
, int rc
)
1314 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1318 atomic_set(&lovset
->set_completes
, 0);
1320 err
= lov_fini_statfs_set(lovset
);
1321 return rc
? rc
: err
;
1324 static int lov_statfs_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1325 __u64 max_age
, struct ptlrpc_request_set
*rqset
)
1327 struct obd_device
*obd
= class_exp2obd(exp
);
1328 struct lov_request_set
*set
;
1329 struct lov_request
*req
;
1330 struct list_head
*pos
;
1331 struct lov_obd
*lov
;
1334 LASSERT(oinfo
!= NULL
);
1335 LASSERT(oinfo
->oi_osfs
!= NULL
);
1338 rc
= lov_prep_statfs_set(obd
, oinfo
, &set
);
1342 list_for_each(pos
, &set
->set_list
) {
1343 req
= list_entry(pos
, struct lov_request
, rq_link
);
1344 rc
= obd_statfs_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1345 &req
->rq_oi
, max_age
, rqset
);
1350 if (rc
|| list_empty(&rqset
->set_requests
)) {
1353 atomic_set(&set
->set_completes
, 0);
1354 err
= lov_fini_statfs_set(set
);
1355 return rc
? rc
: err
;
1358 LASSERT(rqset
->set_interpret
== NULL
);
1359 rqset
->set_interpret
= lov_statfs_interpret
;
1360 rqset
->set_arg
= (void *)set
;
1364 static int lov_statfs(const struct lu_env
*env
, struct obd_export
*exp
,
1365 struct obd_statfs
*osfs
, __u64 max_age
, __u32 flags
)
1367 struct ptlrpc_request_set
*set
= NULL
;
1368 struct obd_info oinfo
= { { { 0 } } };
1371 /* for obdclass we forbid using obd_statfs_rqset, but prefer using async
1372 * statfs requests */
1373 set
= ptlrpc_prep_set();
1377 oinfo
.oi_osfs
= osfs
;
1378 oinfo
.oi_flags
= flags
;
1379 rc
= lov_statfs_async(exp
, &oinfo
, max_age
, set
);
1381 rc
= ptlrpc_set_wait(set
);
1382 ptlrpc_set_destroy(set
);
1387 static int lov_iocontrol(unsigned int cmd
, struct obd_export
*exp
, int len
,
1388 void *karg
, void *uarg
)
1390 struct obd_device
*obddev
= class_exp2obd(exp
);
1391 struct lov_obd
*lov
= &obddev
->u
.lov
;
1392 int i
= 0, rc
= 0, count
= lov
->desc
.ld_tgt_count
;
1393 struct obd_uuid
*uuidp
;
1396 case IOC_OBD_STATFS
: {
1397 struct obd_ioctl_data
*data
= karg
;
1398 struct obd_device
*osc_obd
;
1399 struct obd_statfs stat_buf
= {0};
1403 memcpy(&index
, data
->ioc_inlbuf2
, sizeof(__u32
));
1407 if (!lov
->lov_tgts
[index
])
1408 /* Try again with the next index */
1410 if (!lov
->lov_tgts
[index
]->ltd_active
)
1413 osc_obd
= class_exp2obd(lov
->lov_tgts
[index
]->ltd_exp
);
1418 if (copy_to_user(data
->ioc_pbuf2
, obd2cli_tgt(osc_obd
),
1419 min((int) data
->ioc_plen2
,
1420 (int) sizeof(struct obd_uuid
))))
1423 flags
= uarg
? *(__u32
*)uarg
: 0;
1424 /* got statfs data */
1425 rc
= obd_statfs(NULL
, lov
->lov_tgts
[index
]->ltd_exp
, &stat_buf
,
1426 cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS
),
1430 if (copy_to_user(data
->ioc_pbuf1
, &stat_buf
,
1431 min((int) data
->ioc_plen1
,
1432 (int) sizeof(stat_buf
))))
1436 case OBD_IOC_LOV_GET_CONFIG
: {
1437 struct obd_ioctl_data
*data
;
1438 struct lov_desc
*desc
;
1443 if (obd_ioctl_getdata(&buf
, &len
, uarg
))
1446 data
= (struct obd_ioctl_data
*)buf
;
1448 if (sizeof(*desc
) > data
->ioc_inllen1
) {
1449 obd_ioctl_freedata(buf
, len
);
1453 if (sizeof(uuidp
->uuid
) * count
> data
->ioc_inllen2
) {
1454 obd_ioctl_freedata(buf
, len
);
1458 if (sizeof(__u32
) * count
> data
->ioc_inllen3
) {
1459 obd_ioctl_freedata(buf
, len
);
1463 desc
= (struct lov_desc
*)data
->ioc_inlbuf1
;
1464 memcpy(desc
, &(lov
->desc
), sizeof(*desc
));
1466 uuidp
= (struct obd_uuid
*)data
->ioc_inlbuf2
;
1467 genp
= (__u32
*)data
->ioc_inlbuf3
;
1468 /* the uuid will be empty for deleted OSTs */
1469 for (i
= 0; i
< count
; i
++, uuidp
++, genp
++) {
1470 if (!lov
->lov_tgts
[i
])
1472 *uuidp
= lov
->lov_tgts
[i
]->ltd_uuid
;
1473 *genp
= lov
->lov_tgts
[i
]->ltd_gen
;
1476 if (copy_to_user(uarg
, buf
, len
))
1478 obd_ioctl_freedata(buf
, len
);
1481 case LL_IOC_LOV_GETSTRIPE
:
1482 rc
= lov_getstripe(exp
, karg
, uarg
);
1484 case OBD_IOC_QUOTACTL
: {
1485 struct if_quotactl
*qctl
= karg
;
1486 struct lov_tgt_desc
*tgt
= NULL
;
1487 struct obd_quotactl
*oqctl
;
1489 if (qctl
->qc_valid
== QC_OSTIDX
) {
1490 if (qctl
->qc_idx
< 0 || count
<= qctl
->qc_idx
)
1493 tgt
= lov
->lov_tgts
[qctl
->qc_idx
];
1494 if (!tgt
|| !tgt
->ltd_exp
)
1496 } else if (qctl
->qc_valid
== QC_UUID
) {
1497 for (i
= 0; i
< count
; i
++) {
1498 tgt
= lov
->lov_tgts
[i
];
1500 !obd_uuid_equals(&tgt
->ltd_uuid
,
1504 if (tgt
->ltd_exp
== NULL
)
1516 LASSERT(tgt
&& tgt
->ltd_exp
);
1517 oqctl
= kzalloc(sizeof(*oqctl
), GFP_NOFS
);
1521 QCTL_COPY(oqctl
, qctl
);
1522 rc
= obd_quotactl(tgt
->ltd_exp
, oqctl
);
1524 QCTL_COPY(qctl
, oqctl
);
1525 qctl
->qc_valid
= QC_OSTIDX
;
1526 qctl
->obd_uuid
= tgt
->ltd_uuid
;
1537 for (i
= 0; i
< count
; i
++) {
1539 struct obd_device
*osc_obd
;
1541 /* OST was disconnected */
1542 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_exp
)
1545 /* ll_umount_begin() sets force flag but for lov, not
1546 * osc. Let's pass it through */
1547 osc_obd
= class_exp2obd(lov
->lov_tgts
[i
]->ltd_exp
);
1548 osc_obd
->obd_force
= obddev
->obd_force
;
1549 err
= obd_iocontrol(cmd
, lov
->lov_tgts
[i
]->ltd_exp
,
1551 if (err
== -ENODATA
&& cmd
== OBD_IOC_POLL_QUOTACHECK
) {
1554 if (lov
->lov_tgts
[i
]->ltd_active
) {
1555 CDEBUG(err
== -ENOTTY
?
1556 D_IOCTL
: D_WARNING
,
1557 "iocontrol OSC %s on OST idx %d cmd %x: err = %d\n",
1558 lov_uuid2str(lov
, i
),
1575 #define FIEMAP_BUFFER_SIZE 4096
1578 * Non-zero fe_logical indicates that this is a continuation FIEMAP
1579 * call. The local end offset and the device are sent in the first
1580 * fm_extent. This function calculates the stripe number from the index.
1581 * This function returns a stripe_no on which mapping is to be restarted.
1583 * This function returns fm_end_offset which is the in-OST offset at which
1584 * mapping should be restarted. If fm_end_offset=0 is returned then caller
1585 * will re-calculate proper offset in next stripe.
1586 * Note that the first extent is passed to lov_get_info via the value field.
1588 * \param fiemap fiemap request header
1589 * \param lsm striping information for the file
1590 * \param fm_start logical start of mapping
1591 * \param fm_end logical end of mapping
1592 * \param start_stripe starting stripe will be returned in this
1594 static u64
fiemap_calc_fm_end_offset(struct ll_user_fiemap
*fiemap
,
1595 struct lov_stripe_md
*lsm
, u64 fm_start
,
1596 u64 fm_end
, int *start_stripe
)
1598 u64 local_end
= fiemap
->fm_extents
[0].fe_logical
;
1599 u64 lun_start
, lun_end
;
1601 int stripe_no
= -1, i
;
1603 if (fiemap
->fm_extent_count
== 0 ||
1604 fiemap
->fm_extents
[0].fe_logical
== 0)
1607 /* Find out stripe_no from ost_index saved in the fe_device */
1608 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1609 struct lov_oinfo
*oinfo
= lsm
->lsm_oinfo
[i
];
1611 if (lov_oinfo_is_dummy(oinfo
))
1614 if (oinfo
->loi_ost_idx
== fiemap
->fm_extents
[0].fe_device
) {
1619 if (stripe_no
== -1)
1622 /* If we have finished mapping on previous device, shift logical
1623 * offset to start of next device */
1624 if ((lov_stripe_intersects(lsm
, stripe_no
, fm_start
, fm_end
,
1625 &lun_start
, &lun_end
)) != 0 &&
1626 local_end
< lun_end
) {
1627 fm_end_offset
= local_end
;
1628 *start_stripe
= stripe_no
;
1630 /* This is a special value to indicate that caller should
1631 * calculate offset in next stripe. */
1633 *start_stripe
= (stripe_no
+ 1) % lsm
->lsm_stripe_count
;
1636 return fm_end_offset
;
1640 * We calculate on which OST the mapping will end. If the length of mapping
1641 * is greater than (stripe_size * stripe_count) then the last_stripe will
1642 * will be one just before start_stripe. Else we check if the mapping
1643 * intersects each OST and find last_stripe.
1644 * This function returns the last_stripe and also sets the stripe_count
1645 * over which the mapping is spread
1647 * \param lsm striping information for the file
1648 * \param fm_start logical start of mapping
1649 * \param fm_end logical end of mapping
1650 * \param start_stripe starting stripe of the mapping
1651 * \param stripe_count the number of stripes across which to map is returned
1653 * \retval last_stripe return the last stripe of the mapping
1655 static int fiemap_calc_last_stripe(struct lov_stripe_md
*lsm
, u64 fm_start
,
1656 u64 fm_end
, int start_stripe
,
1660 u64 obd_start
, obd_end
;
1663 if (fm_end
- fm_start
> lsm
->lsm_stripe_size
* lsm
->lsm_stripe_count
) {
1664 last_stripe
= start_stripe
< 1 ? lsm
->lsm_stripe_count
- 1 :
1666 *stripe_count
= lsm
->lsm_stripe_count
;
1668 for (j
= 0, i
= start_stripe
; j
< lsm
->lsm_stripe_count
;
1669 i
= (i
+ 1) % lsm
->lsm_stripe_count
, j
++) {
1670 if ((lov_stripe_intersects(lsm
, i
, fm_start
, fm_end
,
1671 &obd_start
, &obd_end
)) == 0)
1675 last_stripe
= (start_stripe
+ j
- 1) % lsm
->lsm_stripe_count
;
1682 * Set fe_device and copy extents from local buffer into main return buffer.
1684 * \param fiemap fiemap request header
1685 * \param lcl_fm_ext array of local fiemap extents to be copied
1686 * \param ost_index OST index to be written into the fm_device field for each
1688 * \param ext_count number of extents to be copied
1689 * \param current_extent where to start copying in main extent array
1691 static void fiemap_prepare_and_copy_exts(struct ll_user_fiemap
*fiemap
,
1692 struct ll_fiemap_extent
*lcl_fm_ext
,
1693 int ost_index
, unsigned int ext_count
,
1699 for (ext
= 0; ext
< ext_count
; ext
++) {
1700 lcl_fm_ext
[ext
].fe_device
= ost_index
;
1701 lcl_fm_ext
[ext
].fe_flags
|= FIEMAP_EXTENT_NET
;
1704 /* Copy fm_extent's from fm_local to return buffer */
1705 to
= (char *)fiemap
+ fiemap_count_to_size(current_extent
);
1706 memcpy(to
, lcl_fm_ext
, ext_count
* sizeof(struct ll_fiemap_extent
));
1710 * Break down the FIEMAP request and send appropriate calls to individual OSTs.
1711 * This also handles the restarting of FIEMAP calls in case mapping overflows
1712 * the available number of extents in single call.
1714 static int lov_fiemap(struct lov_obd
*lov
, __u32 keylen
, void *key
,
1715 __u32
*vallen
, void *val
, struct lov_stripe_md
*lsm
)
1717 struct ll_fiemap_info_key
*fm_key
= key
;
1718 struct ll_user_fiemap
*fiemap
= val
;
1719 struct ll_user_fiemap
*fm_local
= NULL
;
1720 struct ll_fiemap_extent
*lcl_fm_ext
;
1722 unsigned int get_num_extents
= 0;
1723 int ost_index
= 0, actual_start_stripe
, start_stripe
;
1724 u64 fm_start
, fm_end
, fm_length
, fm_end_offset
;
1726 int current_extent
= 0, rc
= 0, i
;
1727 int ost_eof
= 0; /* EOF for object */
1728 int ost_done
= 0; /* done with required mapping for this OST? */
1730 int cur_stripe
= 0, cur_stripe_wrap
= 0, stripe_count
;
1731 unsigned int buffer_size
= FIEMAP_BUFFER_SIZE
;
1733 if (!lsm_has_objects(lsm
)) {
1738 if (fiemap_count_to_size(fm_key
->fiemap
.fm_extent_count
) < buffer_size
)
1739 buffer_size
= fiemap_count_to_size(fm_key
->fiemap
.fm_extent_count
);
1741 fm_local
= libcfs_kvzalloc(buffer_size
, GFP_NOFS
);
1742 if (fm_local
== NULL
) {
1746 lcl_fm_ext
= &fm_local
->fm_extents
[0];
1748 count_local
= fiemap_size_to_count(buffer_size
);
1750 memcpy(fiemap
, &fm_key
->fiemap
, sizeof(*fiemap
));
1751 fm_start
= fiemap
->fm_start
;
1752 fm_length
= fiemap
->fm_length
;
1753 /* Calculate start stripe, last stripe and length of mapping */
1754 actual_start_stripe
= start_stripe
= lov_stripe_number(lsm
, fm_start
);
1755 fm_end
= (fm_length
== ~0ULL ? fm_key
->oa
.o_size
:
1756 fm_start
+ fm_length
- 1);
1757 /* If fm_length != ~0ULL but fm_start+fm_length-1 exceeds file size */
1758 if (fm_end
> fm_key
->oa
.o_size
)
1759 fm_end
= fm_key
->oa
.o_size
;
1761 last_stripe
= fiemap_calc_last_stripe(lsm
, fm_start
, fm_end
,
1762 actual_start_stripe
, &stripe_count
);
1764 fm_end_offset
= fiemap_calc_fm_end_offset(fiemap
, lsm
, fm_start
,
1765 fm_end
, &start_stripe
);
1766 if (fm_end_offset
== -EINVAL
) {
1771 if (fiemap_count_to_size(fiemap
->fm_extent_count
) > *vallen
)
1772 fiemap
->fm_extent_count
= fiemap_size_to_count(*vallen
);
1773 if (fiemap
->fm_extent_count
== 0) {
1774 get_num_extents
= 1;
1777 /* Check each stripe */
1778 for (cur_stripe
= start_stripe
, i
= 0; i
< stripe_count
;
1779 i
++, cur_stripe
= (cur_stripe
+ 1) % lsm
->lsm_stripe_count
) {
1780 u64 req_fm_len
; /* Stores length of required mapping */
1781 u64 len_mapped_single_call
;
1782 u64 lun_start
, lun_end
, obd_object_end
;
1783 unsigned int ext_count
;
1785 cur_stripe_wrap
= cur_stripe
;
1787 /* Find out range of mapping on this stripe */
1788 if ((lov_stripe_intersects(lsm
, cur_stripe
, fm_start
, fm_end
,
1789 &lun_start
, &obd_object_end
)) == 0)
1792 if (lov_oinfo_is_dummy(lsm
->lsm_oinfo
[cur_stripe
])) {
1797 /* If this is a continuation FIEMAP call and we are on
1798 * starting stripe then lun_start needs to be set to
1800 if (fm_end_offset
!= 0 && cur_stripe
== start_stripe
)
1801 lun_start
= fm_end_offset
;
1803 if (fm_length
!= ~0ULL) {
1804 /* Handle fm_start + fm_length overflow */
1805 if (fm_start
+ fm_length
< fm_start
)
1806 fm_length
= ~0ULL - fm_start
;
1807 lun_end
= lov_size_to_stripe(lsm
, fm_start
+ fm_length
,
1813 if (lun_start
== lun_end
)
1816 req_fm_len
= obd_object_end
- lun_start
;
1817 fm_local
->fm_length
= 0;
1818 len_mapped_single_call
= 0;
1820 /* If the output buffer is very large and the objects have many
1821 * extents we may need to loop on a single OST repeatedly */
1825 if (get_num_extents
== 0) {
1826 /* Don't get too many extents. */
1827 if (current_extent
+ count_local
>
1828 fiemap
->fm_extent_count
)
1829 count_local
= fiemap
->fm_extent_count
-
1833 lun_start
+= len_mapped_single_call
;
1834 fm_local
->fm_length
= req_fm_len
- len_mapped_single_call
;
1835 req_fm_len
= fm_local
->fm_length
;
1836 fm_local
->fm_extent_count
= count_local
;
1837 fm_local
->fm_mapped_extents
= 0;
1838 fm_local
->fm_flags
= fiemap
->fm_flags
;
1840 fm_key
->oa
.o_oi
= lsm
->lsm_oinfo
[cur_stripe
]->loi_oi
;
1841 ost_index
= lsm
->lsm_oinfo
[cur_stripe
]->loi_ost_idx
;
1843 if (ost_index
< 0 ||
1844 ost_index
>= lov
->desc
.ld_tgt_count
) {
1849 /* If OST is inactive, return extent with UNKNOWN flag */
1850 if (!lov
->lov_tgts
[ost_index
]->ltd_active
) {
1851 fm_local
->fm_flags
|= FIEMAP_EXTENT_LAST
;
1852 fm_local
->fm_mapped_extents
= 1;
1854 lcl_fm_ext
[0].fe_logical
= lun_start
;
1855 lcl_fm_ext
[0].fe_length
= obd_object_end
-
1857 lcl_fm_ext
[0].fe_flags
|= FIEMAP_EXTENT_UNKNOWN
;
1862 fm_local
->fm_start
= lun_start
;
1863 fm_local
->fm_flags
&= ~FIEMAP_FLAG_DEVICE_ORDER
;
1864 memcpy(&fm_key
->fiemap
, fm_local
, sizeof(*fm_local
));
1865 *vallen
= fiemap_count_to_size(fm_local
->fm_extent_count
);
1866 rc
= obd_get_info(NULL
,
1867 lov
->lov_tgts
[ost_index
]->ltd_exp
,
1868 keylen
, key
, vallen
, fm_local
, lsm
);
1873 ext_count
= fm_local
->fm_mapped_extents
;
1874 if (ext_count
== 0) {
1876 /* If last stripe has hole at the end,
1877 * then we need to return */
1878 if (cur_stripe_wrap
== last_stripe
) {
1879 fiemap
->fm_mapped_extents
= 0;
1885 /* If we just need num of extents then go to next device */
1886 if (get_num_extents
) {
1887 current_extent
+= ext_count
;
1891 len_mapped_single_call
= lcl_fm_ext
[ext_count
-1].fe_logical
-
1892 lun_start
+ lcl_fm_ext
[ext_count
- 1].fe_length
;
1894 /* Have we finished mapping on this device? */
1895 if (req_fm_len
<= len_mapped_single_call
)
1898 /* Clear the EXTENT_LAST flag which can be present on
1900 if (lcl_fm_ext
[ext_count
-1].fe_flags
& FIEMAP_EXTENT_LAST
)
1901 lcl_fm_ext
[ext_count
- 1].fe_flags
&=
1902 ~FIEMAP_EXTENT_LAST
;
1904 curr_loc
= lov_stripe_size(lsm
,
1905 lcl_fm_ext
[ext_count
- 1].fe_logical
+
1906 lcl_fm_ext
[ext_count
- 1].fe_length
,
1908 if (curr_loc
>= fm_key
->oa
.o_size
)
1911 fiemap_prepare_and_copy_exts(fiemap
, lcl_fm_ext
,
1912 ost_index
, ext_count
,
1915 current_extent
+= ext_count
;
1917 /* Ran out of available extents? */
1918 if (current_extent
>= fiemap
->fm_extent_count
)
1920 } while (ost_done
== 0 && ost_eof
== 0);
1922 if (cur_stripe_wrap
== last_stripe
)
1927 /* Indicate that we are returning device offsets unless file just has
1929 if (lsm
->lsm_stripe_count
> 1)
1930 fiemap
->fm_flags
|= FIEMAP_FLAG_DEVICE_ORDER
;
1932 if (get_num_extents
)
1933 goto skip_last_device_calc
;
1935 /* Check if we have reached the last stripe and whether mapping for that
1936 * stripe is done. */
1937 if (cur_stripe_wrap
== last_stripe
) {
1938 if (ost_done
|| ost_eof
)
1939 fiemap
->fm_extents
[current_extent
- 1].fe_flags
|=
1943 skip_last_device_calc
:
1944 fiemap
->fm_mapped_extents
= current_extent
;
1951 static int lov_get_info(const struct lu_env
*env
, struct obd_export
*exp
,
1952 __u32 keylen
, void *key
, __u32
*vallen
, void *val
,
1953 struct lov_stripe_md
*lsm
)
1955 struct obd_device
*obddev
= class_exp2obd(exp
);
1956 struct lov_obd
*lov
= &obddev
->u
.lov
;
1959 if (!vallen
|| !val
)
1964 if (KEY_IS(KEY_LOCK_TO_STRIPE
)) {
1967 struct ldlm_lock
*lock
;
1969 struct ldlm_res_id
*res_id
= &data
->lock
->l_resource
->lr_name
;
1970 struct lov_oinfo
*loi
;
1971 __u32
*stripe
= val
;
1973 if (*vallen
< sizeof(*stripe
)) {
1977 *vallen
= sizeof(*stripe
);
1979 /* XXX This is another one of those bits that will need to
1980 * change if we ever actually support nested LOVs. It uses
1981 * the lock's export to find out which stripe it is. */
1982 /* XXX - it's assumed all the locks for deleted OSTs have
1983 * been cancelled. Also, the export for deleted OSTs will
1984 * be NULL and won't match the lock's export. */
1985 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1986 loi
= lsm
->lsm_oinfo
[i
];
1987 if (lov_oinfo_is_dummy(loi
))
1990 if (!lov
->lov_tgts
[loi
->loi_ost_idx
])
1992 if (lov
->lov_tgts
[loi
->loi_ost_idx
]->ltd_exp
==
1993 data
->lock
->l_conn_export
&&
1994 ostid_res_name_eq(&loi
->loi_oi
, res_id
)) {
2000 LDLM_ERROR(data
->lock
, "lock on inode without such object");
2001 dump_lsm(D_ERROR
, lsm
);
2004 } else if (KEY_IS(KEY_LAST_ID
)) {
2005 struct obd_id_info
*info
= val
;
2006 __u32 size
= sizeof(u64
);
2007 struct lov_tgt_desc
*tgt
;
2009 LASSERT(*vallen
== sizeof(struct obd_id_info
));
2010 tgt
= lov
->lov_tgts
[info
->idx
];
2012 if (!tgt
|| !tgt
->ltd_active
) {
2017 rc
= obd_get_info(env
, tgt
->ltd_exp
, keylen
, key
,
2018 &size
, info
->data
, NULL
);
2021 } else if (KEY_IS(KEY_LOVDESC
)) {
2022 struct lov_desc
*desc_ret
= val
;
2023 *desc_ret
= lov
->desc
;
2027 } else if (KEY_IS(KEY_FIEMAP
)) {
2028 rc
= lov_fiemap(lov
, keylen
, key
, vallen
, val
, lsm
);
2030 } else if (KEY_IS(KEY_CONNECT_FLAG
)) {
2031 struct lov_tgt_desc
*tgt
;
2032 __u64 ost_idx
= *((__u64
*)val
);
2034 LASSERT(*vallen
== sizeof(__u64
));
2035 LASSERT(ost_idx
< lov
->desc
.ld_tgt_count
);
2036 tgt
= lov
->lov_tgts
[ost_idx
];
2038 if (!tgt
|| !tgt
->ltd_exp
) {
2043 *((__u64
*)val
) = exp_connect_flags(tgt
->ltd_exp
);
2046 } else if (KEY_IS(KEY_TGT_COUNT
)) {
2047 *((int *)val
) = lov
->desc
.ld_tgt_count
;
2059 static int lov_set_info_async(const struct lu_env
*env
, struct obd_export
*exp
,
2060 u32 keylen
, void *key
, u32 vallen
,
2061 void *val
, struct ptlrpc_request_set
*set
)
2063 struct obd_device
*obddev
= class_exp2obd(exp
);
2064 struct lov_obd
*lov
= &obddev
->u
.lov
;
2067 struct lov_tgt_desc
*tgt
;
2068 unsigned incr
, check_uuid
,
2069 do_inactive
, no_set
;
2070 unsigned next_id
= 0, mds_con
= 0, capa
= 0;
2072 incr
= check_uuid
= do_inactive
= no_set
= 0;
2075 set
= ptlrpc_prep_set();
2081 count
= lov
->desc
.ld_tgt_count
;
2083 if (KEY_IS(KEY_NEXT_ID
)) {
2084 count
= vallen
/ sizeof(struct obd_id_info
);
2085 vallen
= sizeof(u64
);
2086 incr
= sizeof(struct obd_id_info
);
2089 } else if (KEY_IS(KEY_CHECKSUM
)) {
2091 } else if (KEY_IS(KEY_EVICT_BY_NID
)) {
2092 /* use defaults: do_inactive = incr = 0; */
2093 } else if (KEY_IS(KEY_MDS_CONN
)) {
2095 } else if (KEY_IS(KEY_CAPA_KEY
)) {
2097 } else if (KEY_IS(KEY_CACHE_SET
)) {
2098 LASSERT(lov
->lov_cache
== NULL
);
2099 lov
->lov_cache
= val
;
2103 for (i
= 0; i
< count
; i
++, val
= (char *)val
+ incr
) {
2105 tgt
= lov
->lov_tgts
[((struct obd_id_info
*)val
)->idx
];
2107 tgt
= lov
->lov_tgts
[i
];
2109 /* OST was disconnected */
2110 if (!tgt
|| !tgt
->ltd_exp
)
2113 /* OST is inactive and we don't want inactive OSCs */
2114 if (!tgt
->ltd_active
&& !do_inactive
)
2118 struct mds_group_info
*mgi
;
2120 LASSERT(vallen
== sizeof(*mgi
));
2121 mgi
= (struct mds_group_info
*)val
;
2123 /* Only want a specific OSC */
2124 if (mgi
->uuid
&& !obd_uuid_equals(mgi
->uuid
,
2128 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2129 keylen
, key
, sizeof(int),
2131 } else if (next_id
) {
2132 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2133 keylen
, key
, vallen
,
2134 ((struct obd_id_info
*)val
)->data
, set
);
2136 struct mds_capa_info
*info
= (struct mds_capa_info
*)val
;
2138 LASSERT(vallen
== sizeof(*info
));
2140 /* Only want a specific OSC */
2142 !obd_uuid_equals(info
->uuid
, &tgt
->ltd_uuid
))
2145 err
= obd_set_info_async(env
, tgt
->ltd_exp
, keylen
,
2146 key
, sizeof(*info
->capa
),
2149 /* Only want a specific OSC */
2151 !obd_uuid_equals(val
, &tgt
->ltd_uuid
))
2154 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2155 keylen
, key
, vallen
, val
, set
);
2164 err
= ptlrpc_set_wait(set
);
2167 ptlrpc_set_destroy(set
);
2172 void lov_stripe_lock(struct lov_stripe_md
*md
)
2173 __acquires(&md
->lsm_lock
)
2175 LASSERT(md
->lsm_lock_owner
!= current_pid());
2176 spin_lock(&md
->lsm_lock
);
2177 LASSERT(md
->lsm_lock_owner
== 0);
2178 md
->lsm_lock_owner
= current_pid();
2180 EXPORT_SYMBOL(lov_stripe_lock
);
2182 void lov_stripe_unlock(struct lov_stripe_md
*md
)
2183 __releases(&md
->lsm_lock
)
2185 LASSERT(md
->lsm_lock_owner
== current_pid());
2186 md
->lsm_lock_owner
= 0;
2187 spin_unlock(&md
->lsm_lock
);
2189 EXPORT_SYMBOL(lov_stripe_unlock
);
2191 static int lov_quotactl(struct obd_device
*obd
, struct obd_export
*exp
,
2192 struct obd_quotactl
*oqctl
)
2194 struct lov_obd
*lov
= &obd
->u
.lov
;
2195 struct lov_tgt_desc
*tgt
;
2197 __u64 bhardlimit
= 0;
2200 if (oqctl
->qc_cmd
!= LUSTRE_Q_QUOTAON
&&
2201 oqctl
->qc_cmd
!= LUSTRE_Q_QUOTAOFF
&&
2202 oqctl
->qc_cmd
!= Q_GETOQUOTA
&&
2203 oqctl
->qc_cmd
!= Q_INITQUOTA
&&
2204 oqctl
->qc_cmd
!= LUSTRE_Q_SETQUOTA
&&
2205 oqctl
->qc_cmd
!= Q_FINVALIDATE
) {
2206 CERROR("bad quota opc %x for lov obd", oqctl
->qc_cmd
);
2212 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2215 tgt
= lov
->lov_tgts
[i
];
2220 if (!tgt
->ltd_active
|| tgt
->ltd_reap
) {
2221 if (oqctl
->qc_cmd
== Q_GETOQUOTA
&&
2222 lov
->lov_tgts
[i
]->ltd_activate
) {
2224 CERROR("ost %d is inactive\n", i
);
2226 CDEBUG(D_HA
, "ost %d is inactive\n", i
);
2231 err
= obd_quotactl(tgt
->ltd_exp
, oqctl
);
2233 if (tgt
->ltd_active
&& !rc
)
2238 if (oqctl
->qc_cmd
== Q_GETOQUOTA
) {
2239 curspace
+= oqctl
->qc_dqblk
.dqb_curspace
;
2240 bhardlimit
+= oqctl
->qc_dqblk
.dqb_bhardlimit
;
2245 if (oqctl
->qc_cmd
== Q_GETOQUOTA
) {
2246 oqctl
->qc_dqblk
.dqb_curspace
= curspace
;
2247 oqctl
->qc_dqblk
.dqb_bhardlimit
= bhardlimit
;
2252 static int lov_quotacheck(struct obd_device
*obd
, struct obd_export
*exp
,
2253 struct obd_quotactl
*oqctl
)
2255 struct lov_obd
*lov
= &obd
->u
.lov
;
2260 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2261 if (!lov
->lov_tgts
[i
])
2264 /* Skip quota check on the administratively disabled OSTs. */
2265 if (!lov
->lov_tgts
[i
]->ltd_activate
) {
2266 CWARN("lov idx %d was administratively disabled, skip quotacheck on it.\n",
2271 if (!lov
->lov_tgts
[i
]->ltd_active
) {
2272 CERROR("lov idx %d inactive\n", i
);
2278 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2281 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_activate
)
2284 err
= obd_quotacheck(lov
->lov_tgts
[i
]->ltd_exp
, oqctl
);
2295 static struct obd_ops lov_obd_ops
= {
2296 .o_owner
= THIS_MODULE
,
2297 .o_setup
= lov_setup
,
2298 .o_precleanup
= lov_precleanup
,
2299 .o_cleanup
= lov_cleanup
,
2300 /*.o_process_config = lov_process_config,*/
2301 .o_connect
= lov_connect
,
2302 .o_disconnect
= lov_disconnect
,
2303 .o_statfs
= lov_statfs
,
2304 .o_statfs_async
= lov_statfs_async
,
2305 .o_packmd
= lov_packmd
,
2306 .o_unpackmd
= lov_unpackmd
,
2307 .o_create
= lov_create
,
2308 .o_destroy
= lov_destroy
,
2309 .o_getattr_async
= lov_getattr_async
,
2310 .o_setattr_async
= lov_setattr_async
,
2311 .o_adjust_kms
= lov_adjust_kms
,
2312 .o_find_cbdata
= lov_find_cbdata
,
2313 .o_iocontrol
= lov_iocontrol
,
2314 .o_get_info
= lov_get_info
,
2315 .o_set_info_async
= lov_set_info_async
,
2316 .o_notify
= lov_notify
,
2317 .o_pool_new
= lov_pool_new
,
2318 .o_pool_rem
= lov_pool_remove
,
2319 .o_pool_add
= lov_pool_add
,
2320 .o_pool_del
= lov_pool_del
,
2321 .o_getref
= lov_getref
,
2322 .o_putref
= lov_putref
,
2323 .o_quotactl
= lov_quotactl
,
2324 .o_quotacheck
= lov_quotacheck
,
2327 struct kmem_cache
*lov_oinfo_slab
;
2329 static int __init
lov_init(void)
2331 struct lprocfs_static_vars lvars
= { NULL
};
2334 /* print an address of _any_ initialized kernel symbol from this
2335 * module, to allow debugging with gdb that doesn't support data
2336 * symbols from modules.*/
2337 CDEBUG(D_INFO
, "Lustre LOV module (%p).\n", &lov_caches
);
2339 rc
= lu_kmem_init(lov_caches
);
2343 lov_oinfo_slab
= kmem_cache_create("lov_oinfo",
2344 sizeof(struct lov_oinfo
),
2345 0, SLAB_HWCACHE_ALIGN
, NULL
);
2346 if (lov_oinfo_slab
== NULL
) {
2347 lu_kmem_fini(lov_caches
);
2350 lprocfs_lov_init_vars(&lvars
);
2352 rc
= class_register_type(&lov_obd_ops
, NULL
,
2353 LUSTRE_LOV_NAME
, &lov_device_type
);
2356 kmem_cache_destroy(lov_oinfo_slab
);
2357 lu_kmem_fini(lov_caches
);
2363 static void /*__exit*/ lov_exit(void)
2365 class_unregister_type(LUSTRE_LOV_NAME
);
2366 kmem_cache_destroy(lov_oinfo_slab
);
2368 lu_kmem_fini(lov_caches
);
2371 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
2372 MODULE_DESCRIPTION("Lustre Logical Object Volume OBD driver");
2373 MODULE_LICENSE("GPL");
2374 MODULE_VERSION(LUSTRE_VERSION_STRING
);
2376 module_init(lov_init
);
2377 module_exit(lov_exit
);